C++ (Cpp) tuple3 Examples

Example #1

File: compute_outgoing_tuple_test.c Project: alphadx/NAT64

static bool test_4to6(l4_protocol l4_proto)
{
	struct tuple incoming, outgoing;
	bool success = true;

	incoming.src.addr.ipv4 = remote_ipv4;
	incoming.dst.addr.ipv4 = local_ipv4;
	incoming.src.l4_id = 123; /* Whatever */
	incoming.dst.l4_id = 80; /* Lookup will use this. */
	incoming.l3_proto = L3PROTO_IPV4;
	incoming.l4_proto = l4_proto;

	if (l4_proto != L4PROTO_ICMP) {
		success &= assert_equals_int(VER_CONTINUE, tuple5(&incoming, &outgoing), "Function5 call");
		success &= assert_equals_u16(123, outgoing.src.l4_id, "Source port");
		success &= assert_equals_u16(1500, outgoing.dst.l4_id, "Destination port");
	} else {
		success &= assert_equals_int(VER_CONTINUE, tuple3(&incoming, &outgoing), "Function3 call");
		success &= assert_equals_u16(1500, outgoing.icmp_id, "ICMP ID");
	}
	success &= assert_equals_ipv6(&local_ipv6, &outgoing.src.addr.ipv6, "Source address");
	success &= assert_equals_ipv6(&remote_ipv6, &outgoing.dst.addr.ipv6, "Destination address");
	success &= assert_equals_u16(L3PROTO_IPV6, outgoing.l3_proto, "Layer-3 protocol");
	success &= assert_equals_u8(l4_proto, outgoing.l4_proto, "Layer-4 protocol");

	return success;
}

Example #2

File: skip_list_map_test.cpp Project: gitter-badger/peloton

// Test basic functionality
TEST_F(SkipListMapTest, BasicTest) {

  std::vector<catalog::Column> columns;

  catalog::Column column1(VALUE_TYPE_INTEGER, GetTypeSize(VALUE_TYPE_INTEGER), "A", true);
  columns.push_back(column1);
  catalog::Schema *schema(new catalog::Schema(columns));
  std::vector<storage::Tuple*> tuples;

  storage::Tuple *tuple1(new storage::Tuple(schema, true));
  tuple1->SetValue(0, ValueFactory::GetIntegerValue(1), nullptr);
  tuples.push_back(tuple1);
  storage::Tuple *tuple2(new storage::Tuple(schema, true));
  tuple2->SetValue(0, ValueFactory::GetIntegerValue(2), nullptr);
  tuples.push_back(tuple2);
  storage::Tuple *tuple3(new storage::Tuple(schema, true));
  tuple3->SetValue(0, ValueFactory::GetIntegerValue(3), nullptr);
  tuples.push_back(tuple3);

  LOG_INFO("%s", tuple1->GetInfo().c_str());

  SkipListMap<key_type, value_type, key_comparator> map;

  EXPECT_TRUE(map.IsEmpty());

  size_t const element_count = tuples.size();

  for (size_t element = 0; element < element_count; ++element ) {
    key_type key;
    key.SetFromKey(tuples[element]);

    value_type val = &foo;
    auto status = map.Insert(key, val);
    EXPECT_TRUE(status);
    status = map.Insert(key, val);
    EXPECT_FALSE(status);
  }

  for (size_t element = 0; element < element_count; ++element ) {
    key_type key;
    key.SetFromKey(tuples[element]);

    value_type value = &bar;
    auto status = map.Find(key, value);
    EXPECT_TRUE(status);
    EXPECT_EQ(foo.block, value->block);
    LOG_INFO("bar : %d %d", value->block, value->offset);
  }

  for(auto tuple : tuples) {
    delete tuple;
  }
  delete schema;
}