C++ (Cpp) expect_equal Examples

Example #1

0

Show file

File: flat_input_test.cpp Project: ddennedy/movit

TEST(FlatInput, UpdatedData) {
	const int width = 2;
	const int height = 4;

	float data[width * height] = {
		0.0, 1.0,
		0.5, 0.5,
		0.7, 0.2,
		1.0, 0.6,
	};
	float out_data[width * height];

	EffectChainTester tester(NULL, width, height);

	ImageFormat format;
	format.color_space = COLORSPACE_sRGB;
	format.gamma_curve = GAMMA_LINEAR;

	FlatInput *input = new FlatInput(format, FORMAT_GRAYSCALE, GL_FLOAT, width, height);
	input->set_pixel_data(data);
	tester.get_chain()->add_input(input);

	tester.run(out_data, GL_RED, COLORSPACE_sRGB, GAMMA_LINEAR);
	expect_equal(data, out_data, width, height);

	data[6] = 0.3;
	input->invalidate_pixel_data();

	tester.run(out_data, GL_RED, COLORSPACE_sRGB, GAMMA_LINEAR);
	expect_equal(data, out_data, width, height);
}

Example #2

0

Show file

File: blob_test.c Project: Echelon9/mesa

/* Test that data values are written and read with proper alignment. */
static void
test_alignment(void)
{
   void *ctx = ralloc_context(NULL);
   struct blob *blob;
   struct blob_reader reader;
   uint8_t bytes[] = "ABCDEFGHIJKLMNOP";
   size_t delta, last, num_bytes;

   blob = blob_create(ctx);

   /* First, write an intptr value to the blob and capture that size. This is
    * the expected offset between any pair of intptr values (if written with
    * alignment).
    */
   blob_write_intptr(blob, (intptr_t) blob);

   delta = blob->size;
   last = blob->size;

   /* Then loop doing the following:
    *
    *   1. Write an unaligned number of bytes
    *   2. Verify that write results in an unaligned size
    *   3. Write an intptr_t value
    *   2. Verify that that write results in an aligned size
    */
   for (num_bytes = 1; num_bytes < sizeof(intptr_t); num_bytes++) {
      blob_write_bytes(blob, bytes, num_bytes);

      expect_unequal(delta, blob->size - last, "unaligned write of bytes");

      blob_write_intptr(blob, (intptr_t) blob);

      expect_equal(2 * delta, blob->size - last, "aligned write of intptr");

      last = blob->size;
   }

   /* Finally, test that reading also does proper alignment. Since we know
    * that values were written with all the right alignment, all we have to do
    * here is verify that correct values are read.
    */
   blob_reader_init(&reader, blob->data, blob->size);

   expect_equal((intptr_t) blob, blob_read_intptr(&reader),
                "read of initial, aligned intptr_t");

   for (num_bytes = 1; num_bytes < sizeof(intptr_t); num_bytes++) {
      expect_equal_bytes(bytes, blob_read_bytes(&reader, num_bytes),
                         num_bytes, "unaligned read of bytes");
      expect_equal((intptr_t) blob, blob_read_intptr(&reader),
                   "aligned read of intptr_t");
   }

   ralloc_free(ctx);
}

Example #3

0

Show file

File: consume.hpp Project: drewet/jtl

  void jtl::consume_group::test<4>() /* copy */
  {
    jtl::reset();

    std::vector<jtl::tracked_copy> in(6);
    std::vector<jtl::tracked_eater<jtl::tracked_copy>> out(3);
    jtl::algorithm::consume_copy<2>(std::begin(in), std::end(in), std::begin(out));

    /* First copied into their new home, then that home is copied into the vector. */
    expect_equal(jtl::tracked_copy::count, 12ul);
    expect_equal(jtl::tracked_move::count, 0ul);
  }

Example #4

0

Show file

File: consume.hpp Project: drewet/jtl

 void jtl::consume_group::test<0>() /* vector -> vector */
 {
   std::vector<int> in{ 0, 1, 2, 3, 4, 5 };
   std::vector<std::vector<int>> out(3);
   jtl::algorithm::consume<2>(std::begin(in), std::end(in),
                              std::begin(out));
   for(int i{}; i < 3; ++i)
   {
     expect_equal(out[i].size(), 2ul);
     expect_equal(out[i][0], i * 2);
     expect_equal(out[i][1], (i * 2) + 1);
   }
 }

Example #5

0

Show file

File: consume.hpp Project: drewet/jtl

 void jtl::consume_group::test<1>() /* vector -> vector (push_back) */
 {
   std::vector<int> in{ 0, 1, 2, 3, 4, 5 };
   std::vector<std::vector<int>> out;
   jtl::algorithm::consume<2>(std::begin(in), std::end(in),
                              jtl::iterator::back_inserter(out));
   for(int i{}; i < 3; ++i)
   {
     expect_equal(out[i].size(), 2ul);
     expect_equal(out[i][0], i * 2);
     expect_equal(out[i][1], (i * 2) + 1);
   }
 }

Example #6

0

Show file

File: consume.hpp Project: drewet/jtl

  void jtl::consume_group::test<2>() /* aggregate */
  {
    struct name
    { std::string first, last; };

    std::stringstream ss{ "john|doe|peter|parker" };
    std::vector<name> names;
    jtl::algorithm::consume<2>(jtl::iterator::stream_delim<>{ ss, '|' },
                               jtl::iterator::stream_delim<>{},
                               jtl::iterator::back_inserter(names));
    expect_equal(names[0].first, "john");
    expect_equal(names[0].last, "doe");
    expect_equal(names[1].first, "peter");
    expect_equal(names[1].last, "parker");
  }

Example #7

0

Show file

File: main.cpp Project: Jenkin0603/myvim

 void ex_1_group::test<1>()
 {
   int const i{};
   float const f{ 3.14 };
   float const f2{ f * 2.0f };
   expect_equal(i, f, f2);
 }

Example #8

0

Show file