Exemple #1
0
 private void WorkerDoWork(object sender, DoWorkEventArgs e)
 {
     while (true)
     {
         if (stoppingTest)
         {
             break;
         }
         try
         {
             DateTime modelTime, firstDate;
             if (robotContext.MakeStep(out modelTime, out firstDate))
             {
                 break;
             }
             // прогресс
             var passedHours = (modelTime - firstDate).TotalHours;
             var totalHours  = (robotContext.TimeTo - firstDate).TotalHours;
             var progress    = totalHours == 0
                                ? 1.0
                                : passedHours / totalHours;
             UpdateProgressAsynch(progress);
         }
         catch (Exception ex)
         {
             Console.WriteLine(ex);
             break;
         }
     }
 }
        public void DealsDone()
        {
            #region "расчётные" значения, с которыми будут сравниваться состония робота
            var dealData = new[]
            {
                new
                {
                    dealDate  = new DateTime(2013, 10, 31, 17, 0, 0),
                    mainKijun = 1.3683d,
                    bid       = 1.3636,
                    dayCandlePackerFirstCandle =
                        new CandleData(1.35280f, 1.35870f, 1.35170f, 1.35320f, new DateTime(2013, 10, 1),
                                       new DateTime(2013, 10, 2))
                },
                new
                {
                    dealDate  = new DateTime(2013, 11, 7, 18, 0, 0),
                    mainKijun = 1.34395d,
                    bid       = 1.3368,
                    dayCandlePackerFirstCandle =
                        new CandleData(1.35630f, 1.35910f, 1.35420f, 1.35780f, new DateTime(2013, 10, 7),
                                       new DateTime(2013, 10, 8))
                },
                new
                {
                    dealDate  = new DateTime(2013, 11, 27, 0, 0, 0),
                    mainKijun = 1.3544d,
                    bid       = 1.3561,
                    dayCandlePackerFirstCandle =
                        new CandleData(1.3799f, 1.3812f, 1.3797f, 1.3807f, new DateTime(2013, 10, 26),
                                       new DateTime(2013, 10, 27))
                }
            };

            #endregion

            try
            {
                DateTime modelTime, realTime;
                while (true)
                {
                    if (context.MakeStep(out modelTime, out realTime))
                    {
                        break;
                    }

                    var calculatedDealValue = dealData.FirstOrDefault(x => x.dealDate == modelTime);
                    if (calculatedDealValue == null)
                    {
                        continue;
                    }

                    Assert.IsTrue(calculatedDealValue.mainKijun.RoughCompares(bot.kijunMain, 0.0001),
                                  string.Format(
                                      "киджун основного тайм фрейма не совпал с расчётным. Свеча от {0}. Расчётный {1} / рассчитал робот {2}",
                                      modelTime, calculatedDealValue.mainKijun, bot.kijunMain));

                    var dayCandlePackerFirstCandle = bot.subQueue[0].First;
                    Assert.AreEqual(calculatedDealValue.dayCandlePackerFirstCandle.timeOpen,
                                    dayCandlePackerFirstCandle.timeOpen,
                                    string.Format(
                                        "не совпадает время открытия первой свечи из очереди (D1) для расчёта киджуна. Расчётный {0} / рассчитал робот {1}",
                                        calculatedDealValue.dayCandlePackerFirstCandle.timeOpen,
                                        dayCandlePackerFirstCandle.timeOpen));

                    Assert.AreEqual(calculatedDealValue.dayCandlePackerFirstCandle.timeClose,
                                    dayCandlePackerFirstCandle.timeClose,
                                    string.Format(
                                        "не совпадает время закрытия первой свечи из очереди (D1) для расчёта киджуна. Расчётный {0} / рассчитал робот {1}",
                                        calculatedDealValue.dayCandlePackerFirstCandle.timeClose,
                                        dayCandlePackerFirstCandle.timeClose));

                    Assert.IsTrue(
                        calculatedDealValue.dayCandlePackerFirstCandle.open.RoughCompares(
                            dayCandlePackerFirstCandle.open, 0.0001f),
                        string.Format(
                            "не совпадает цена открытия первой свечи из очереди (D1) для расчёта киджуна. Расчётный {0} / рассчитал робот {1}",
                            calculatedDealValue.dayCandlePackerFirstCandle.open, dayCandlePackerFirstCandle.open));

                    Assert.IsTrue(
                        calculatedDealValue.dayCandlePackerFirstCandle.low.RoughCompares(
                            dayCandlePackerFirstCandle.low, 0.0001f),
                        string.Format(
                            "не совпадает наименьшая цена первой свечи из очереди (D1) для расчёта киджуна. Расчётный {0} / рассчитал робот {1}",
                            calculatedDealValue.dayCandlePackerFirstCandle.low, dayCandlePackerFirstCandle.low));

                    Assert.IsTrue(
                        calculatedDealValue.dayCandlePackerFirstCandle.high.RoughCompares(
                            dayCandlePackerFirstCandle.high, 0.0001f),
                        string.Format(
                            "не совпадает наибольшая первой свечи из очереди (D1) для расчёта киджуна. Расчётный {0} / рассчитал робот {1}",
                            calculatedDealValue.dayCandlePackerFirstCandle.high, dayCandlePackerFirstCandle.high));


                    Assert.IsTrue(calculatedDealValue.bid.RoughCompares(bot.candleMainTimeFrame.close, 0.0001),
                                  string.Format(
                                      "объём сделки не совпадает с расчётным. Расчётный {0} / рассчитал робот {1}",
                                      calculatedDealValue.bid, bot.candleMainTimeFrame.close));
                }
            }
            finally
            {
                context.FinalizeTest();
            }
        }
        public void TradeTest()
        {
            //Список хранит время и состояние робота, на этот момент времени. Это состояние задаётся руками и берётся, например, из графика.
            var checkPoints = new List <Cortege2 <DateTime, RobotMA.RobotMAInnerState> >
            {
                new Cortege2 <DateTime, RobotMA.RobotMAInnerState>(
                    new DateTime(2013, 12, 26, 18, 30, 0),
                    new RobotMA.RobotMAInnerState
                {
                    maValueFast = 1.3688,
                    maValueSlow = 1.36891,
                    maDifSign   = 0
                }),
                new Cortege2 <DateTime, RobotMA.RobotMAInnerState>(
                    new DateTime(2013, 12, 26, 21, 30, 0),
                    new RobotMA.RobotMAInnerState
                {
                    maValueFast = 1.3689,
                    maValueSlow = 1.36896,
                    maDifSign   = 0
                }),
                new Cortege2 <DateTime, RobotMA.RobotMAInnerState>(
                    new DateTime(2013, 12, 27, 19, 30, 0),
                    new RobotMA.RobotMAInnerState
                {
                    maValueFast = 1.38078,
                    maValueSlow = 1.38133,
                    maDifSign   = 1
                }),
                new Cortege2 <DateTime, RobotMA.RobotMAInnerState>(
                    new DateTime(2013, 12, 27, 23, 0, 0),
                    new RobotMA.RobotMAInnerState
                {
                    maValueFast = 1.37662,
                    maValueSlow = 1.37981,
                    maDifSign   = 1
                })
            };
            var curCheckPointIndex = 0;

            try
            {
                while (true)
                {
                    DateTime modelTime, realTime;
                    if (context.MakeStep(out modelTime, out realTime))
                    {
                        break;
                    }

                    if (bot.debugAction != null)
                    {
                        bot.debugAction -= DebugAction;
                        curCheckPointIndex++;
                        if (curCheckPointIndex == checkPoints.Count)
                        {
                            curCheckPointIndex = -1;
                        }
                    }

                    if (curCheckPointIndex >= 0 && modelTime == checkPoints[curCheckPointIndex].a)
                    {
                        specimanState    = checkPoints[curCheckPointIndex].b;
                        bot.debugAction += DebugAction;
                    }
                }
            }
            finally
            {
                context.FinalizeTest();
            }
        }