C++ (Cpp) EXPECT_PRED1 примеры использования

Пример #1

Файл: dot_test.cpp Проект: stan-dev/math

TEST(MathFunctions, dot_nan) {
    std::vector<double> x(3), y(3);
    x[0] = 2.33;
    x[1] = 8.88;
    x[2] = 9.81;
    y[0] = 2.46;
    y[1] = 4.45;
    y[2] = 1.03;

    double nan = std::numeric_limits<double>::quiet_NaN();
    x[2] = nan;

    EXPECT_PRED1(boost::math::isnan<double>,
                 stan::math::dot(x, y));
    EXPECT_PRED1(boost::math::isnan<double>,
                 stan::math::dot(y, x));


    x[0] = nan;
    x[1] = nan;
    x[2] = nan;
    EXPECT_PRED1(boost::math::isnan<double>,
                 stan::math::dot(x, y));
    EXPECT_PRED1(boost::math::isnan<double>,
                 stan::math::dot(y, x));


    EXPECT_PRED1(boost::math::isnan<double>,
                 stan::math::dot(x, x));
}

Пример #2

Файл: sub_test.cpp Проект: aseyboldt/math

TEST(MathFunctions, sub_nan) {
  double nan = std::numeric_limits<double>::quiet_NaN();
  std::vector<double> x(3), y(3), result(3);
  
  x[0] = 1.0;
  x[1] = 2.0;
  x[2] = nan;
  
  y[0] = 0.5;
  y[1] = 1.0;
  y[2] = 4.0;
  
  EXPECT_NO_THROW(stan::math::sub(x, y, result));
  EXPECT_FLOAT_EQ(0.5, result[0]);
  EXPECT_FLOAT_EQ(1.0, result[1]);
  EXPECT_PRED1(boost::math::isnan<double>,
               result[2]);


  EXPECT_NO_THROW(stan::math::sub(y, x, result));
  EXPECT_FLOAT_EQ(-0.5, result[0]);
  EXPECT_FLOAT_EQ(-1.0, result[1]);
  EXPECT_PRED1(boost::math::isnan<double>,
               result[2]);

  
  y[2] = nan;
  EXPECT_NO_THROW(stan::math::sub(x, y, result));
  EXPECT_FLOAT_EQ(0.5, result[0]);
  EXPECT_FLOAT_EQ(1.0, result[1]);
  EXPECT_PRED1(boost::math::isnan<double>,
               result[2]);

}

Пример #3

Файл: multiply_log_test.cpp Проект: javaosos/stan

TEST(MathFunctions, multiply_log_nan) {
  double nan = std::numeric_limits<double>::quiet_NaN();
  
  EXPECT_PRED1(boost::math::isnan<double>,
               stan::math::multiply_log(2.0, nan));
  EXPECT_PRED1(boost::math::isnan<double>,
               stan::math::multiply_log(nan, 3.0));
  EXPECT_PRED1(boost::math::isnan<double>,
               stan::math::multiply_log(nan, nan));
}

Пример #4

Файл: inverse_softmax_test.cpp Проект: javaosos/stan

TEST(MathFunctions, inverse_softmax_nan) {
  double nan = std::numeric_limits<double>::quiet_NaN();

  std::vector<double> simplex(2);
  std::vector<double> y(2);
  
  simplex[0] = nan;
  simplex[1] = nan;

  stan::math::inverse_softmax(simplex, y);
  EXPECT_PRED1(boost::math::isnan<double>,
               y[0]);

  EXPECT_PRED1(boost::math::isnan<double>,
               y[1]);
}

Пример #5

Файл: max_test.cpp Проект: javaosos/stan

TEST(MathFunctions, max_nan) {
  double nan = std::numeric_limits<double>::quiet_NaN();

  EXPECT_FLOAT_EQ(0.0, stan::math::max(nan, 0.0));
  EXPECT_PRED1(boost::math::isnan<double>,
               stan::math::max(0.0, nan));
}

Пример #6

Файл: dot_self_test.cpp Проект: javaosos/stan

TEST(MathFunctions, dot_self_nan) {
  std::vector<double> x(3);
  x[0] = 2.33;
  x[1] = 8.88;
  x[2] = 9.81;

  double nan = std::numeric_limits<double>::quiet_NaN();
  x[2] = nan;

  EXPECT_PRED1(boost::math::isnan<double>,
               stan::math::dot_self(x));

  x[0] = nan;
  x[1] = nan;
  x[2] = nan;
  EXPECT_PRED1(boost::math::isnan<double>,
               stan::math::dot_self(x));
}

Пример #7

Файл: deque_internals.cpp Проект: galkinvv/pradeque

TEST(diofantiane_solve, macro_via_class)
{
    EXPECT_EQ(DSolve<  1>::Solution(), 1);
    EXPECT_EQ(DSolve<  3>::Solution(),0xaaaaaaaaaaaaaaabULL);
    EXPECT_EQ(DSolve<  5>::Solution(),0xcccccccccccccccdULL);
	EXPECT_PRED1(checkCorrectDiofantioanSolving, 5);
	EXPECT_PRED1(checkCorrectDiofantioanSolving, 7);
	EXPECT_PRED1(checkCorrectDiofantioanSolving, 9);
	EXPECT_PRED1(checkCorrectDiofantioanSolving, 11);
	EXPECT_PRED1(checkCorrectDiofantioanSolving, 13);
	EXPECT_PRED1(checkCorrectDiofantioanSolving, 15);
	EXPECT_PRED1(checkCorrectDiofantioanSolving, 17);
}

Пример #8

Файл: test.cpp Проект: michaelmaltese/ronnie

TEST (RuntimeErrors, ExpectedCommand) {
	CaosRuntime *runtime = caos_runtime_new();
	
	CaosLexError *lex_error = NULL;
	CaosScript *script = caos_script_from_string (CAOS_EXODUS, &lex_error, "notacommand ");
	ASSERT_FALSE (lex_error);

	CaosContext *context = caos_context_new (runtime, script);

	// Expected command, got Symbol:notacommand, at line 1
	caos_tick (context, NULL);
	CaosError *error = NULL;
	error = caos_get_error (context);
	ASSERT_TRUE (error);  

	EXPECT_EQ (CAOS_EXPECTED_COMMAND, error->type);
	EXPECT_PRED1 (caos_value_is_symbol, error->token);
	EXPECT_STREQ ("notacommand", caos_value_to_symbol (error->token));
	EXPECT_EQ (1, error->token.line);
}

Пример #9

Файл: test.cpp Проект: michaelmaltese/ronnie

TEST (RuntimeErrors, FailedToFastForward) {
	CaosRuntime *runtime = caos_runtime_new();
	caos_register_function (runtime, "doif", c_doif, NULL);
	
	
	CaosLexError *lex_error = NULL;
	CaosScript *script = caos_script_from_string (CAOS_EXODUS, &lex_error, "doif 0 = 4");
	ASSERT_FALSE (lex_error);
	
	CaosContext *context = caos_context_new (runtime, script);
	
	caos_tick (context, NULL);
	CaosError *error = NULL;
	error = caos_get_error (context);
	ASSERT_TRUE (error);  
	
	EXPECT_EQ (CAOS_FAILED_TO_FAST_FORWARD, error->type);
	EXPECT_PRED1 (caos_value_is_eoi, error->token);
	EXPECT_EQ (1, error->token.line);
}

Пример #10

Файл: test.cpp Проект: michaelmaltese/ronnie

TEST (RuntimeErrors, ExpectedExpression) {
	CaosRuntime *runtime = caos_runtime_new();
	caos_register_function (runtime, "outs", c_outs, NULL);
	
	
	CaosLexError *lex_error = NULL;
	CaosScript *script = caos_script_from_string (CAOS_EXODUS, &lex_error, "outs\n\n outs");
	ASSERT_FALSE (lex_error);
	
	CaosContext *context = caos_context_new (runtime, script);
	
	caos_tick (context, NULL);
	CaosError *error = NULL;
	error = caos_get_error (context);
	ASSERT_TRUE (error);  
	
	EXPECT_EQ (CAOS_EXPECTED_EXPRESSION, error->type);
	EXPECT_PRED1 (caos_value_is_symbol, error->token);
	EXPECT_STREQ ("outs", caos_value_to_symbol (error->token));
	EXPECT_EQ (3, error->token.line);
}

Пример #11

Файл: scaled_add_test.cpp Проект: noamross/stan

TEST(MathFunctions, scaled_add_nan) {
    double nan = std::numeric_limits<double>::quiet_NaN();
    std::vector<double> x(3), y(3);
    double lambda;

    x[0] = 0;
    x[1] = 0;
    x[2] = 0;
    y[0] = 2;
    y[1] = 3;
    y[2] = 4;

    lambda = 0.5;

    EXPECT_NO_THROW(stan::math::scaled_add(x, y, nan));
    EXPECT_PRED1(boost::math::isnan<double>, x[0]);
    EXPECT_PRED1(boost::math::isnan<double>, x[1]);
    EXPECT_PRED1(boost::math::isnan<double>, x[2]);

    x[0] = 0;
    x[1] = 0;
    x[2] = 0;
    y[1] = nan;
    EXPECT_NO_THROW(stan::math::scaled_add(x, y, lambda));
    EXPECT_FLOAT_EQ(1.0, x[0]);
    EXPECT_PRED1(boost::math::isnan<double>, x[1]);
    EXPECT_FLOAT_EQ(2.0, x[2]);

    x[0] = 0;
    x[1] = 0;
    x[2] = 0;
    EXPECT_NO_THROW(stan::math::scaled_add(x, y, nan));
    EXPECT_PRED1(boost::math::isnan<double>, x[0]);
    EXPECT_PRED1(boost::math::isnan<double>, x[1]);
    EXPECT_PRED1(boost::math::isnan<double>, x[2]);
}

Пример #12

Файл: lmgamma_test.cpp Проект: aseyboldt/math

TEST(MathFunctions, lmgamma_nan) {
  double nan = std::numeric_limits<double>::quiet_NaN();
  
  EXPECT_PRED1(boost::math::isnan<double>,
               stan::math::lmgamma(2, nan));
}

Пример #13

Файл: square_test.cpp Проект: aseyboldt/math

TEST(MathFunctions, square_nan) {
  double nan = std::numeric_limits<double>::quiet_NaN();
  
  EXPECT_PRED1(boost::math::isnan<double>,
               stan::math::square(nan));
}