#include "price_speedometer.mqh"

void OnStart() {
  test_period_in_ticks_zero_empty_ticks();
  test_period_in_ticks_non_zero_empty_ticks();
  test_period_in_ticks_zero_non_empty_ticks();
  test_period_in_ticks_smaller_than_non_empty_ticks();
  test_period_in_ticks_bigger_than_non_empty_ticks();
  test_period_in_milliseconds_zero_empty_ticks();
  test_period_in_milliseconds_non_zero_empty_ticks();
  test_period_in_milliseconds_zero_non_empty_ticks();
  test_period_in_milliseconds_smaller_than_non_empty_ticks();
  test_period_in_milliseconds_bigger_than_non_empty_ticks();
  test_copy_constructor();
  test_copy_assignment();
  Print("All tests passed.");
  return;
}

void test_period_in_ticks_zero_empty_ticks() {
  const int ticks_capacity = 256;
  const int period_in_ticks = 0;
  const long period_in_milliseconds = 0l;
  Price_speedometer price_speedometer(ticks_capacity, period_in_ticks,
                                      period_in_milliseconds);
  price_speedometer.calculate_price_speeds();
  price_speedometer.calculate_percents();
  const double input_value_speed_per_ticks = 0.0;
  const double input_value_directional_speed_per_ticks = 0.0;
  const double input_value_percent_per_ticks = 0.0;
  const double output_value_speed_per_ticks =
      price_speedometer.get_speed_per_ticks();
  const double output_value_directional_speed_per_ticks =
      price_speedometer.get_directional_speed_per_ticks();
  const double output_value_percent_per_ticks =
      price_speedometer.get_percent_per_ticks();
  if (output_value_speed_per_ticks != input_value_speed_per_ticks) {
    Alert("Test failed in line ", __LINE__, ".");
    ExpertRemove();
  }
  if (output_value_directional_speed_per_ticks !=
      input_value_directional_speed_per_ticks) {
    Alert("Test failed in line ", __LINE__, ".");
    ExpertRemove();
  }
  if (output_value_percent_per_ticks != input_value_percent_per_ticks) {
    Alert("Test failed in line ", __LINE__, ".");
    ExpertRemove();
  }
  return;
}

void test_period_in_ticks_non_zero_empty_ticks() {
  const int ticks_capacity = 256;
  const int period_in_ticks = 5;
  const long period_in_milliseconds = 0l;
  Price_speedometer price_speedometer(ticks_capacity, period_in_ticks,
                                      period_in_milliseconds);
  price_speedometer.calculate_price_speeds();
  price_speedometer.calculate_percents();
  const double input_value_speed_per_ticks = 0.0;
  const double input_value_directional_speed_per_ticks = 0.0;
  const double input_value_percent_per_ticks = 0.0;
  const double output_value_speed_per_ticks =
      price_speedometer.get_speed_per_ticks();
  const double output_value_directional_speed_per_ticks =
      price_speedometer.get_directional_speed_per_ticks();
  const double output_value_percent_per_ticks =
      price_speedometer.get_percent_per_ticks();
  if (output_value_speed_per_ticks != input_value_speed_per_ticks) {
    Alert("Test failed in line ", __LINE__, ".");
    ExpertRemove();
  }
  if (output_value_directional_speed_per_ticks !=
      input_value_directional_speed_per_ticks) {
    Alert("Test failed in line ", __LINE__, ".");
    ExpertRemove();
  }
  if (output_value_percent_per_ticks != input_value_percent_per_ticks) {
    Alert("Test failed in line ", __LINE__, ".");
    ExpertRemove();
  }
  return;
}

void test_period_in_ticks_zero_non_empty_ticks() {
  const int ticks_capacity = 256;
  const int period_in_ticks = 0;
  const long period_in_milliseconds = 0l;
  Price_speedometer price_speedometer(ticks_capacity, period_in_ticks,
                                      period_in_milliseconds);
  const datetime time = 0ul;
  const double bid = 0.0;
  const double ask = 0.0;
  double last = 1.0;
  const ulong volume = 0ul;
  const long time_msc = 1l;
  const uint flags = 0u;
  const double volume_real = 0.0;
  const MqlTick tick_1 = {time,   bid,      ask,   last,
                          volume, time_msc, flags, volume_real};
  price_speedometer.add_tick(tick_1);
  last = -2.0;
  const MqlTick tick_2 = {time,   bid,      ask,   last,
                          volume, time_msc, flags, volume_real};
  price_speedometer.add_tick(tick_2);
  last = 3.0;
  const MqlTick tick_3 = {time,   bid,      ask,   last,
                          volume, time_msc, flags, volume_real};
  price_speedometer.add_tick(tick_3);
  last = -4.0;
  const MqlTick tick_4 = {time,   bid,      ask,   last,
                          volume, time_msc, flags, volume_real};
  price_speedometer.add_tick(tick_4);
  last = 5.0;
  const MqlTick tick_5 = {time,   bid,      ask,   last,
                          volume, time_msc, flags, volume_real};
  price_speedometer.add_tick(tick_5);
  price_speedometer.calculate_price_speeds();
  price_speedometer.calculate_percents();
  const double input_value_speed_per_ticks = 0.0;
  const double input_value_directional_speed_per_ticks = 0.0;
  const double input_value_percent_per_ticks = 0.0;
  const double output_value_speed_per_ticks =
      price_speedometer.get_speed_per_ticks();
  const double output_value_directional_speed_per_ticks =
      price_speedometer.get_directional_speed_per_ticks();
  const double output_value_percent_per_ticks =
      price_speedometer.get_percent_per_ticks();
  if (output_value_speed_per_ticks != input_value_speed_per_ticks) {
    Alert("Test failed in line ", __LINE__, ".");
    ExpertRemove();
  }
  if (output_value_directional_speed_per_ticks !=
      input_value_directional_speed_per_ticks) {
    Alert("Test failed in line ", __LINE__, ".");
    ExpertRemove();
  }
  if (output_value_percent_per_ticks != input_value_percent_per_ticks) {
    Alert("Test failed in line ", __LINE__, ".");
    ExpertRemove();
  }
  return;
}

void test_period_in_ticks_smaller_than_non_empty_ticks() {
  const int ticks_capacity = 256;
  const int period_in_ticks = 3;
  const long period_in_milliseconds = 0l;
  Price_speedometer price_speedometer(ticks_capacity, period_in_ticks,
                                      period_in_milliseconds);
  const datetime time = 0ul;
  const double bid = 0.0;
  const double ask = 0.0;
  double last = 1.0;
  const ulong volume = 0ul;
  const long time_msc = 1l;
  const uint flags = 0u;
  const double volume_real = 0.0;
  const MqlTick tick_1 = {time,   bid,      ask,   last,
                          volume, time_msc, flags, volume_real};
  price_speedometer.add_tick(tick_1);
  last = -2.0;
  const MqlTick tick_2 = {time,   bid,      ask,   last,
                          volume, time_msc, flags, volume_real};
  price_speedometer.add_tick(tick_2);
  last = 3.0;
  const MqlTick tick_3 = {time,   bid,      ask,   last,
                          volume, time_msc, flags, volume_real};
  price_speedometer.add_tick(tick_3);
  last = -4.0;
  const MqlTick tick_4 = {time,   bid,      ask,   last,
                          volume, time_msc, flags, volume_real};
  price_speedometer.add_tick(tick_4);
  last = 5.0;
  const MqlTick tick_5 = {time,   bid,      ask,   last,
                          volume, time_msc, flags, volume_real};
  price_speedometer.add_tick(tick_5);
  price_speedometer.calculate_price_speeds();
  price_speedometer.calculate_percents();
  const double input_value_speed_per_ticks = 16.0;
  const double input_value_directional_speed_per_ticks = 2.0;
  const double input_value_percent_per_ticks = 2.0 / 16.0 * 100.0;
  const double output_value_speed_per_ticks =
      price_speedometer.get_speed_per_ticks();
  const double output_value_directional_speed_per_ticks =
      price_speedometer.get_directional_speed_per_ticks();
  const double output_value_percent_per_ticks =
      price_speedometer.get_percent_per_ticks();
  if (output_value_speed_per_ticks != input_value_speed_per_ticks) {
    Alert("Test failed in line ", __LINE__, ".");
    ExpertRemove();
  }
  if (output_value_directional_speed_per_ticks !=
      input_value_directional_speed_per_ticks) {
    Alert("Test failed in line ", __LINE__, ".");
    ExpertRemove();
  }
  if (output_value_percent_per_ticks != input_value_percent_per_ticks) {
    Alert("Test failed in line ", __LINE__, ".");
    ExpertRemove();
  }
  return;
}

void test_period_in_ticks_bigger_than_non_empty_ticks() {
  const int ticks_capacity = 256;
  const int period_in_ticks = 7;
  const long period_in_milliseconds = 0l;
  Price_speedometer price_speedometer(ticks_capacity, period_in_ticks,
                                      period_in_milliseconds);
  const datetime time = 0ul;
  const double bid = 0.0;
  const double ask = 0.0;
  double last = 1.0;
  const ulong volume = 0ul;
  const long time_msc = 1l;
  const uint flags = 0u;
  const double volume_real = 0.0;
  const MqlTick tick_1 = {time,   bid,      ask,   last,
                          volume, time_msc, flags, volume_real};
  price_speedometer.add_tick(tick_1);
  last = -2.0;
  const MqlTick tick_2 = {time,   bid,      ask,   last,
                          volume, time_msc, flags, volume_real};
  price_speedometer.add_tick(tick_2);
  last = 3.0;
  const MqlTick tick_3 = {time,   bid,      ask,   last,
                          volume, time_msc, flags, volume_real};
  price_speedometer.add_tick(tick_3);
  last = -4.0;
  const MqlTick tick_4 = {time,   bid,      ask,   last,
                          volume, time_msc, flags, volume_real};
  price_speedometer.add_tick(tick_4);
  last = 5.0;
  const MqlTick tick_5 = {time,   bid,      ask,   last,
                          volume, time_msc, flags, volume_real};
  price_speedometer.add_tick(tick_5);
  price_speedometer.calculate_price_speeds();
  price_speedometer.calculate_percents();
  const double input_value_speed_per_ticks = 24.0;
  const double input_value_directional_speed_per_ticks = 4.0;
  const double input_value_percent_per_ticks = 4.0 / 24.0 * 100.0;
  const double output_value_speed_per_ticks =
      price_speedometer.get_speed_per_ticks();
  const double output_value_directional_speed_per_ticks =
      price_speedometer.get_directional_speed_per_ticks();
  const double output_value_percent_per_ticks =
      price_speedometer.get_percent_per_ticks();
  if (output_value_speed_per_ticks != input_value_speed_per_ticks) {
    Alert("Test failed in line ", __LINE__, ".");
    ExpertRemove();
  }
  if (output_value_directional_speed_per_ticks !=
      input_value_directional_speed_per_ticks) {
    Alert("Test failed in line ", __LINE__, ".");
    ExpertRemove();
  }
  if (output_value_percent_per_ticks != input_value_percent_per_ticks) {
    Alert("Test failed in line ", __LINE__, ".");
    ExpertRemove();
  }
  return;
}

void test_period_in_milliseconds_zero_empty_ticks() {
  const int ticks_capacity = 256;
  const int period_in_ticks = 0;
  const long period_in_milliseconds = 0l;
  Price_speedometer price_speedometer(ticks_capacity, period_in_ticks,
                                      period_in_milliseconds);
  price_speedometer.calculate_price_speeds();
  price_speedometer.calculate_percents();
  const double input_value_speed_per_milliseconds = 0.0;
  const double input_value_directional_speed_per_milliseconds = 0.0;
  const double input_value_percent_per_milliseconds = 0.0;
  const double output_value_speed_per_milliseconds =
      price_speedometer.get_speed_per_milliseconds();
  const double output_value_directional_speed_per_milliseconds =
      price_speedometer.get_directional_speed_per_milliseconds();
  const double output_value_percent_per_milliseconds =
      price_speedometer.get_percent_per_milliseconds();
  if (output_value_speed_per_milliseconds !=
      input_value_speed_per_milliseconds) {
    Alert("Test failed in line ", __LINE__, ".");
    ExpertRemove();
  }
  if (output_value_directional_speed_per_milliseconds !=
      input_value_directional_speed_per_milliseconds) {
    Alert("Test failed in line ", __LINE__, ".");
    ExpertRemove();
  }
  if (output_value_percent_per_milliseconds !=
      input_value_percent_per_milliseconds) {
    Alert("Test failed in line ", __LINE__, ".");
    ExpertRemove();
  }
  return;
}

void test_period_in_milliseconds_non_zero_empty_ticks() {
  const int ticks_capacity = 256;
  const int period_in_ticks = 0;
  const long period_in_milliseconds = 5l;
  Price_speedometer price_speedometer(ticks_capacity, period_in_ticks,
                                      period_in_milliseconds);
  price_speedometer.calculate_price_speeds();
  price_speedometer.calculate_percents();
  const double input_value_speed_per_milliseconds = 0.0;
  const double input_value_directional_speed_per_milliseconds = 0.0;
  const double input_value_percent_per_milliseconds = 0.0;
  const double output_value_speed_per_milliseconds =
      price_speedometer.get_speed_per_milliseconds();
  const double output_value_directional_speed_per_milliseconds =
      price_speedometer.get_directional_speed_per_milliseconds();
  const double output_value_percent_per_milliseconds =
      price_speedometer.get_percent_per_milliseconds();
  if (output_value_speed_per_milliseconds !=
      input_value_speed_per_milliseconds) {
    Alert("Test failed in line ", __LINE__, ".");
    ExpertRemove();
  }
  if (output_value_directional_speed_per_milliseconds !=
      input_value_directional_speed_per_milliseconds) {
    Alert("Test failed in line ", __LINE__, ".");
    ExpertRemove();
  }
  if (output_value_percent_per_milliseconds !=
      input_value_percent_per_milliseconds) {
    Alert("Test failed in line ", __LINE__, ".");
    ExpertRemove();
  }
  return;
}

void test_period_in_milliseconds_zero_non_empty_ticks() {
  const int ticks_capacity = 256;
  const int period_in_ticks = 0;
  const long period_in_milliseconds = 0l;
  Price_speedometer price_speedometer(ticks_capacity, period_in_ticks,
                                      period_in_milliseconds);
  const datetime time = 0ul;
  const double bid = 0.0;
  const double ask = 0.0;
  double last = 1.0;
  const ulong volume = 0ul;
  long time_msc = 1l;
  const uint flags = 0u;
  const double volume_real = 0.0;
  const MqlTick tick_1 = {time,   bid,      ask,   last,
                          volume, time_msc, flags, volume_real};
  price_speedometer.add_tick(tick_1);
  last = -2.0;
  time_msc = 2l;
  const MqlTick tick_2 = {time,   bid,      ask,   last,
                          volume, time_msc, flags, volume_real};
  price_speedometer.add_tick(tick_2);
  last = 3.0;
  time_msc = 3l;
  const MqlTick tick_3 = {time,   bid,      ask,   last,
                          volume, time_msc, flags, volume_real};
  price_speedometer.add_tick(tick_3);
  last = -4.0;
  time_msc = 4l;
  const MqlTick tick_4 = {time,   bid,      ask,   last,
                          volume, time_msc, flags, volume_real};
  price_speedometer.add_tick(tick_4);
  last = 5.0;
  time_msc = 5l;
  const MqlTick tick_5 = {time,   bid,      ask,   last,
                          volume, time_msc, flags, volume_real};
  price_speedometer.add_tick(tick_5);
  price_speedometer.calculate_price_speeds();
  price_speedometer.calculate_percents();
  const double input_value_speed_per_milliseconds = 0.0;
  const double input_value_directional_speed_per_milliseconds = 0.0;
  const double input_value_percent_per_milliseconds = 0.0;
  const double output_value_speed_per_milliseconds =
      price_speedometer.get_speed_per_milliseconds();
  const double output_value_directional_speed_per_milliseconds =
      price_speedometer.get_directional_speed_per_milliseconds();
  const double output_value_percent_per_milliseconds =
      price_speedometer.get_percent_per_milliseconds();
  if (output_value_speed_per_milliseconds !=
      input_value_speed_per_milliseconds) {
    Alert("Test failed in line ", __LINE__, ".");
    ExpertRemove();
  }
  if (output_value_directional_speed_per_milliseconds !=
      input_value_directional_speed_per_milliseconds) {
    Alert("Test failed in line ", __LINE__, ".");
    ExpertRemove();
  }
  if (output_value_percent_per_milliseconds !=
      input_value_percent_per_milliseconds) {
    Alert("Test failed in line ", __LINE__, ".");
    ExpertRemove();
  }
  return;
}

void test_period_in_milliseconds_smaller_than_non_empty_ticks() {
  const int ticks_capacity = 256;
  const int period_in_ticks = 0;
  const long period_in_milliseconds = 2l;
  Price_speedometer price_speedometer(ticks_capacity, period_in_ticks,
                                      period_in_milliseconds);
  const datetime time = 0ul;
  const double bid = 0.0;
  const double ask = 0.0;
  double last = 1.0;
  const ulong volume = 0ul;
  long time_msc = 1l;
  const uint flags = 0u;
  const double volume_real = 0.0;
  const MqlTick tick_1 = {time,   bid,      ask,   last,
                          volume, time_msc, flags, volume_real};
  price_speedometer.add_tick(tick_1);
  last = -2.0;
  time_msc = 2l;
  const MqlTick tick_2 = {time,   bid,      ask,   last,
                          volume, time_msc, flags, volume_real};
  price_speedometer.add_tick(tick_2);
  last = 3.0;
  time_msc = 3l;
  const MqlTick tick_3 = {time,   bid,      ask,   last,
                          volume, time_msc, flags, volume_real};
  price_speedometer.add_tick(tick_3);
  last = -4.0;
  time_msc = 4l;
  const MqlTick tick_4 = {time,   bid,      ask,   last,
                          volume, time_msc, flags, volume_real};
  price_speedometer.add_tick(tick_4);
  last = 5.0;
  time_msc = 5l;
  const MqlTick tick_5 = {time,   bid,      ask,   last,
                          volume, time_msc, flags, volume_real};
  price_speedometer.add_tick(tick_5);
  price_speedometer.calculate_price_speeds();
  price_speedometer.calculate_percents();
  const double input_value_speed_per_milliseconds = 16.0;
  const double input_value_directional_speed_per_milliseconds = 2.0;
  const double input_value_percent_per_milliseconds = 2.0 / 16.0 * 100.0;
  const double output_value_speed_per_milliseconds =
      price_speedometer.get_speed_per_milliseconds();
  const double output_value_directional_speed_per_milliseconds =
      price_speedometer.get_directional_speed_per_milliseconds();
  const double output_value_percent_per_milliseconds =
      price_speedometer.get_percent_per_milliseconds();
  if (output_value_speed_per_milliseconds !=
      input_value_speed_per_milliseconds) {
    Alert("Test failed in line ", __LINE__, ".");
    ExpertRemove();
  }
  if (output_value_directional_speed_per_milliseconds !=
      input_value_directional_speed_per_milliseconds) {
    Alert("Test failed in line ", __LINE__, ".");
    ExpertRemove();
  }
  if (output_value_percent_per_milliseconds !=
      input_value_percent_per_milliseconds) {
    Alert("Test failed in line ", __LINE__, ".");
    ExpertRemove();
  }
  return;
}

void test_period_in_milliseconds_bigger_than_non_empty_ticks() {
  const int ticks_capacity = 256;
  const int period_in_ticks = 0;
  const long period_in_milliseconds = 8l;
  Price_speedometer price_speedometer(ticks_capacity, period_in_ticks,
                                      period_in_milliseconds);
  const datetime time = 0ul;
  const double bid = 0.0;
  const double ask = 0.0;
  double last = 1.0;
  const ulong volume = 0ul;
  long time_msc = 1l;
  const uint flags = 0u;
  const double volume_real = 0.0;
  const MqlTick tick_1 = {time,   bid,      ask,   last,
                          volume, time_msc, flags, volume_real};
  price_speedometer.add_tick(tick_1);
  last = -2.0;
  time_msc = 2l;
  const MqlTick tick_2 = {time,   bid,      ask,   last,
                          volume, time_msc, flags, volume_real};
  price_speedometer.add_tick(tick_2);
  last = 3.0;
  time_msc = 3l;
  const MqlTick tick_3 = {time,   bid,      ask,   last,
                          volume, time_msc, flags, volume_real};
  price_speedometer.add_tick(tick_3);
  last = -4.0;
  time_msc = 4l;
  const MqlTick tick_4 = {time,   bid,      ask,   last,
                          volume, time_msc, flags, volume_real};
  price_speedometer.add_tick(tick_4);
  last = 5.0;
  time_msc = 5l;
  const MqlTick tick_5 = {time,   bid,      ask,   last,
                          volume, time_msc, flags, volume_real};
  price_speedometer.add_tick(tick_5);
  price_speedometer.calculate_price_speeds();
  price_speedometer.calculate_percents();
  const double input_value_speed_per_milliseconds = 24.0;
  const double input_value_directional_speed_per_milliseconds = 4.0;
  const double input_value_percent_per_milliseconds = 4.0 / 24.0 * 100.0;
  const double output_value_speed_per_milliseconds =
      price_speedometer.get_speed_per_milliseconds();
  const double output_value_directional_speed_per_milliseconds =
      price_speedometer.get_directional_speed_per_milliseconds();
  const double output_value_percent_per_milliseconds =
      price_speedometer.get_percent_per_milliseconds();
  if (output_value_speed_per_milliseconds !=
      input_value_speed_per_milliseconds) {
    Alert("Test failed in line ", __LINE__, ".");
    ExpertRemove();
  }
  if (output_value_directional_speed_per_milliseconds !=
      input_value_directional_speed_per_milliseconds) {
    Alert("Test failed in line ", __LINE__, ".");
    ExpertRemove();
  }
  if (output_value_percent_per_milliseconds !=
      input_value_percent_per_milliseconds) {
    Alert("Test failed in line ", __LINE__, ".");
    ExpertRemove();
  }
  return;
}

void test_copy_constructor() {
  const int ticks_capacity = 256;
  const int period_in_ticks = 5;
  const long period_in_milliseconds = 0l;
  Price_speedometer price_speedometer_1(ticks_capacity, period_in_ticks,
                                        period_in_milliseconds);
  const datetime time = 0ul;
  const double bid = 0.0;
  const double ask = 0.0;
  double last = 1.0;
  const ulong volume = 0ul;
  const long time_msc = 1l;
  const uint flags = 0u;
  const double volume_real = 0.0;
  const MqlTick tick_1 = {time,   bid,      ask,   last,
                          volume, time_msc, flags, volume_real};
  price_speedometer_1.add_tick(tick_1);
  last = -2.0;
  const MqlTick tick_2 = {time,   bid,      ask,   last,
                          volume, time_msc, flags, volume_real};
  price_speedometer_1.add_tick(tick_2);
  last = 3.0;
  const MqlTick tick_3 = {time,   bid,      ask,   last,
                          volume, time_msc, flags, volume_real};
  price_speedometer_1.add_tick(tick_3);
  last = -4.0;
  const MqlTick tick_4 = {time,   bid,      ask,   last,
                          volume, time_msc, flags, volume_real};
  price_speedometer_1.add_tick(tick_4);
  last = 5.0;
  const MqlTick tick_5 = {time,   bid,      ask,   last,
                          volume, time_msc, flags, volume_real};
  price_speedometer_1.add_tick(tick_5);
  const Price_speedometer price_speedometer_2(price_speedometer_1);
  const double input_value = price_speedometer_1.get_speed_per_ticks();
  const double output_value = price_speedometer_2.get_speed_per_ticks();
  if (output_value != input_value) {
    Alert("Test failed in line ", __LINE__, ".");
    ExpertRemove();
  }
  return;
}

void test_copy_assignment() {
  const int ticks_capacity = 256;
  const int period_in_ticks = 5;
  const long period_in_milliseconds = 0l;
  Price_speedometer price_speedometer_1(ticks_capacity, period_in_ticks,
                                        period_in_milliseconds);
  const datetime time = 0ul;
  const double bid = 0.0;
  const double ask = 0.0;
  double last = 1.0;
  const ulong volume = 0ul;
  const long time_msc = 1l;
  const uint flags = 0u;
  const double volume_real = 0.0;
  const MqlTick tick_1 = {time,   bid,      ask,   last,
                          volume, time_msc, flags, volume_real};
  price_speedometer_1.add_tick(tick_1);
  last = -2.0;
  const MqlTick tick_2 = {time,   bid,      ask,   last,
                          volume, time_msc, flags, volume_real};
  price_speedometer_1.add_tick(tick_2);
  last = 3.0;
  const MqlTick tick_3 = {time,   bid,      ask,   last,
                          volume, time_msc, flags, volume_real};
  price_speedometer_1.add_tick(tick_3);
  last = -4.0;
  const MqlTick tick_4 = {time,   bid,      ask,   last,
                          volume, time_msc, flags, volume_real};
  price_speedometer_1.add_tick(tick_4);
  last = 5.0;
  const MqlTick tick_5 = {time,   bid,      ask,   last,
                          volume, time_msc, flags, volume_real};
  price_speedometer_1.add_tick(tick_5);
  const Price_speedometer price_speedometer_2 = price_speedometer_1;
  const double input_value = price_speedometer_1.get_speed_per_ticks();
  const double output_value = price_speedometer_2.get_speed_per_ticks();
  if (output_value != input_value) {
    Alert("Test failed in line ", __LINE__, ".");
    ExpertRemove();
  }
  return;
}