TestOMPTraits.cpp

Go to the documentation of this file.

//===- TestOMPTraits.cpp - Tests for OMP Trait classes -------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
 
#include "kmp_traits.h"
#include "gtest/gtest.h"
 
using namespace kmp_traits;
 
namespace {
 
//===----------------------------------------------------------------------===//
// kmp_wildcard_trait Tests
//===----------------------------------------------------------------------===//
 
TEST(kmp_wildcard_trait_test, MatchesAnyDevice) {
  kmp_wildcard_trait *trait = new kmp_wildcard_trait();
 
  EXPECT_TRUE(trait->match(0));
  EXPECT_TRUE(trait->match(1));
  EXPECT_TRUE(trait->match(100));
  EXPECT_TRUE(trait->match(-1));
 
  delete trait;
}
 
TEST(kmp_wildcard_trait_test, Equality) {
  kmp_wildcard_trait *t1 = new kmp_wildcard_trait();
  kmp_wildcard_trait *t2 = new kmp_wildcard_trait();
 
  EXPECT_TRUE(*t1 == *t2);
 
  delete t1;
  delete t2;
}
 
//===----------------------------------------------------------------------===//
// kmp_literal_trait Tests
//===----------------------------------------------------------------------===//
 
TEST(kmp_literal_trait_test, MatchesExactDevice) {
  kmp_literal_trait *trait = new kmp_literal_trait(5);
 
  EXPECT_TRUE(trait->match(5));
  EXPECT_FALSE(trait->match(0));
  EXPECT_FALSE(trait->match(4));
  EXPECT_FALSE(trait->match(6));
 
  delete trait;
}
 
TEST(kmp_literal_trait_test, MatchesZero) {
  kmp_literal_trait *trait = new kmp_literal_trait(0);
 
  EXPECT_TRUE(trait->match(0));
  EXPECT_FALSE(trait->match(1));
 
  delete trait;
}
 
#ifndef NDEBUG
TEST(kmp_literal_trait_test, MatchesNegative) {
  EXPECT_DEATH(new kmp_literal_trait(-1), "Device number must be non-negative");
}
#endif
 
TEST(kmp_literal_trait_test, EqualitySameValue) {
  kmp_literal_trait *t1 = new kmp_literal_trait(42);
  kmp_literal_trait *t2 = new kmp_literal_trait(42);
 
  EXPECT_TRUE(*t1 == *t2);
 
  delete t1;
  delete t2;
}
 
TEST(kmp_literal_trait_test, EqualityDifferentValue) {
  kmp_literal_trait *t1 = new kmp_literal_trait(1);
  kmp_literal_trait *t2 = new kmp_literal_trait(2);
 
  EXPECT_FALSE(*t1 == *t2);
 
  delete t1;
  delete t2;
}
 
//===----------------------------------------------------------------------===//
// kmp_uid_trait Tests
//===----------------------------------------------------------------------===//
 
TEST(kmp_uid_trait_test, Construction) {
  kmp_uid_trait *trait = new kmp_uid_trait(kmp_str_ref("test-uid"));
 
  // Just verify it can be constructed without crashing
  delete trait;
}
 
TEST(kmp_uid_trait_test, MatchWithMock) {
  kmp_uid_trait *trait = new kmp_uid_trait(kmp_str_ref("device-0"));
 
  // Uses the mock omp_get_uid_from_device
  EXPECT_TRUE(trait->match(0)); // device-0 matches
  EXPECT_FALSE(trait->match(1)); // device-1 doesn't match
  EXPECT_FALSE(trait->match(2)); // device-2 doesn't match
 
  delete trait;
}
 
TEST(kmp_uid_trait_test, MatchWithCustomMock) {
  kmp_uid_trait *trait = new kmp_uid_trait(kmp_str_ref("custom-uid"));
 
  // Set a custom mock function
  trait->set_uid_from_device([](int device) -> const char * {
    return device == 2 ? "custom-uid" : "other";
  });
 
  EXPECT_FALSE(trait->match(0));
  EXPECT_FALSE(trait->match(1));
  EXPECT_TRUE(trait->match(2)); // custom-uid matches device 2
  EXPECT_FALSE(trait->match(3));
 
  delete trait;
}
 
TEST(kmp_uid_trait_test, EqualitySameUID) {
  kmp_uid_trait *t1 = new kmp_uid_trait(kmp_str_ref("my-device"));
  kmp_uid_trait *t2 = new kmp_uid_trait(kmp_str_ref("my-device"));
 
  EXPECT_TRUE(*t1 == *t2);
 
  delete t1;
  delete t2;
}
 
TEST(kmp_uid_trait_test, EqualityDifferentUID) {
  kmp_uid_trait *t1 = new kmp_uid_trait(kmp_str_ref("device-a"));
  kmp_uid_trait *t2 = new kmp_uid_trait(kmp_str_ref("device-b"));
 
  EXPECT_FALSE(*t1 == *t2);
 
  delete t1;
  delete t2;
}
 
//===----------------------------------------------------------------------===//
// kmp_trait_expr_single Tests
//===----------------------------------------------------------------------===//
 
TEST(kmp_trait_expr_single_test, CreateAndDestroy) {
  kmp_trait_expr_single *expr = new kmp_trait_expr_single();
  EXPECT_NE(expr, nullptr);
  delete expr;
}
 
TEST(kmp_trait_expr_single_test, CreateWithTrait) {
  kmp_trait_expr_single *expr =
      new kmp_trait_expr_single(new kmp_literal_trait(2));
 
  // Mock: 4 devices
  expr->set_num_devices([]() { return 4; });
 
  EXPECT_TRUE(expr->match(2));
  EXPECT_FALSE(expr->match(0));
  EXPECT_FALSE(expr->match(1));
  EXPECT_FALSE(expr->match(5)); // Out of range
 
  delete expr;
}
 
TEST(kmp_trait_expr_single_test, SetTrait) {
  kmp_trait_expr_single *expr = new kmp_trait_expr_single();
  expr->set_trait(new kmp_literal_trait(3));
 
  // Mock: 4 devices
  expr->set_num_devices([]() { return 4; });
 
  EXPECT_TRUE(expr->match(3));
  EXPECT_FALSE(expr->match(0));
 
  delete expr;
}
 
TEST(kmp_trait_expr_single_test, DefaultNotNegated) {
  kmp_trait_expr_single *expr = new kmp_trait_expr_single();
 
  EXPECT_FALSE(expr->is_negated());
 
  delete expr;
}
 
TEST(kmp_trait_expr_single_test, SetNegated) {
  kmp_trait_expr_single *expr = new kmp_trait_expr_single();
 
  expr->set_negated(true);
  EXPECT_TRUE(expr->is_negated());
 
  expr->set_negated(false);
  EXPECT_FALSE(expr->is_negated());
 
  delete expr;
}
 
TEST(kmp_trait_expr_single_test, MatchNegated) {
  kmp_trait_expr_single *expr =
      new kmp_trait_expr_single(new kmp_literal_trait(2));
  expr->set_negated(true);
 
  // Mock: 4 devices
  expr->set_num_devices([]() { return 4; });
 
  // Without negation: matches 2
  // With negation: matches everything in-range except 2
  EXPECT_FALSE(expr->match(2));
  EXPECT_TRUE(expr->match(0));
  EXPECT_TRUE(expr->match(1));
  EXPECT_TRUE(expr->match(3));
  // Out of range devices return false regardless of negation
  EXPECT_FALSE(expr->match(5));
 
  delete expr;
}
 
TEST(kmp_trait_expr_single_test, MatchWildcard) {
  kmp_trait_expr_single *expr =
      new kmp_trait_expr_single(new kmp_wildcard_trait());
 
  // Mock: 4 devices
  expr->set_num_devices([]() { return 4; });
 
  // Wildcard matches any in-range device
  EXPECT_TRUE(expr->match(0));
  EXPECT_TRUE(expr->match(3));
  // Out of range devices return false
  EXPECT_FALSE(expr->match(100));
 
  delete expr;
}
 
TEST(kmp_trait_expr_single_test, Equality) {
  kmp_trait_expr_single *e1 =
      new kmp_trait_expr_single(new kmp_literal_trait(1));
  kmp_trait_expr_single *e2 =
      new kmp_trait_expr_single(new kmp_literal_trait(1));
 
  EXPECT_TRUE(*e1 == *e2);
 
  delete e1;
  delete e2;
}
 
TEST(kmp_trait_expr_single_test, EqualityDifferentTrait) {
  kmp_trait_expr_single *e1 =
      new kmp_trait_expr_single(new kmp_literal_trait(1));
  kmp_trait_expr_single *e2 =
      new kmp_trait_expr_single(new kmp_literal_trait(2));
 
  EXPECT_FALSE(*e1 == *e2);
 
  delete e1;
  delete e2;
}
 
TEST(kmp_trait_expr_single_test, EqualityDifferentNegation) {
  kmp_trait_expr_single *e1 =
      new kmp_trait_expr_single(new kmp_literal_trait(1));
  kmp_trait_expr_single *e2 =
      new kmp_trait_expr_single(new kmp_literal_trait(1));
  e2->set_negated(true);
 
  EXPECT_FALSE(*e1 == *e2);
 
  delete e1;
  delete e2;
}
 
//===----------------------------------------------------------------------===//
// kmp_trait_expr_group Tests
//===----------------------------------------------------------------------===//
 
TEST(kmp_trait_expr_group_test, CreateAndDestroy) {
  kmp_trait_expr_group *group = new kmp_trait_expr_group();
  EXPECT_NE(group, nullptr);
  delete group;
}
 
TEST(kmp_trait_expr_group_test, DefaultTypeIsOR) {
  kmp_trait_expr_group *group = new kmp_trait_expr_group();
 
  EXPECT_EQ(group->get_group_type(), kmp_trait_expr_group::OR);
 
  delete group;
}
 
TEST(kmp_trait_expr_group_test, SetTypeAND) {
  kmp_trait_expr_group *group = new kmp_trait_expr_group();
 
  group->set_group_type(kmp_trait_expr_group::AND);
  EXPECT_EQ(group->get_group_type(), kmp_trait_expr_group::AND);
 
  delete group;
}
 
TEST(kmp_trait_expr_group_test, DefaultNotNegated) {
  kmp_trait_expr_group *group = new kmp_trait_expr_group();
 
  EXPECT_FALSE(group->is_negated());
 
  delete group;
}
 
TEST(kmp_trait_expr_group_test, SetNegated) {
  kmp_trait_expr_group *group = new kmp_trait_expr_group();
 
  group->set_negated(true);
  EXPECT_TRUE(group->is_negated());
 
  group->set_negated(false);
  EXPECT_FALSE(group->is_negated());
 
  delete group;
}
 
TEST(kmp_trait_expr_group_test, AddTraitDirectly) {
  kmp_trait_expr_group *group = new kmp_trait_expr_group();
 
  group->add_expr(new kmp_wildcard_trait());
 
  // Mock: 4 devices
  group->set_num_devices([]() { return 4; });
 
  // Wildcard matches any in-range device
  EXPECT_TRUE(group->match(0));
  EXPECT_TRUE(group->match(3));
  // Out of range devices return false
  EXPECT_FALSE(group->match(100));
 
  delete group;
}
 
TEST(kmp_trait_expr_group_test, AddExpr) {
  kmp_trait_expr_group *group = new kmp_trait_expr_group();
 
  group->add_expr(new kmp_trait_expr_single(new kmp_literal_trait(2)));
 
  // Mock: 4 devices
  group->set_num_devices([]() { return 4; });
 
  EXPECT_TRUE(group->match(2));
  EXPECT_FALSE(group->match(0));
  EXPECT_FALSE(group->match(5)); // Out of range
 
  delete group;
}
 
TEST(kmp_trait_expr_group_test, MatchORSemantics) {
  kmp_trait_expr_group *group = new kmp_trait_expr_group();
  group->set_group_type(kmp_trait_expr_group::OR);
 
  group->add_expr(new kmp_literal_trait(1));
  group->add_expr(new kmp_literal_trait(2));
  group->add_expr(new kmp_literal_trait(3));
 
  // Mock: 5 devices
  group->set_num_devices([]() { return 5; });
 
  // OR: matches if ANY trait matches
  EXPECT_TRUE(group->match(1));
  EXPECT_TRUE(group->match(2));
  EXPECT_TRUE(group->match(3));
  EXPECT_FALSE(group->match(0));
  EXPECT_FALSE(group->match(4));
 
  delete group;
}
 
TEST(kmp_trait_expr_group_test, MatchANDSemantics) {
  kmp_trait_expr_group *group = new kmp_trait_expr_group();
  group->set_group_type(kmp_trait_expr_group::AND);
 
  // For AND to pass, ALL traits must match the same device
  // A single literal only matches one device
  group->add_expr(new kmp_literal_trait(2));
 
  // Mock: 4 devices
  group->set_num_devices([]() { return 4; });
 
  EXPECT_TRUE(group->match(2));
  EXPECT_FALSE(group->match(0));
  // Out of range
  EXPECT_FALSE(group->match(5));
 
  delete group;
}
 
TEST(kmp_trait_expr_group_test, MatchANDWithWildcard) {
  kmp_trait_expr_group *group = new kmp_trait_expr_group();
  group->set_group_type(kmp_trait_expr_group::AND);
 
  group->add_expr(new kmp_wildcard_trait());
  group->add_expr(new kmp_literal_trait(2));
 
  // Mock: 4 devices
  group->set_num_devices([]() { return 4; });
 
  // Wildcard matches all, literal matches 2
  // AND: both must match
  EXPECT_TRUE(group->match(2));
  EXPECT_FALSE(group->match(0));
  // Out of range
  EXPECT_FALSE(group->match(5));
 
  delete group;
}
 
TEST(kmp_trait_expr_group_test, MatchNegated) {
  kmp_trait_expr_group *group = new kmp_trait_expr_group();
 
  group->add_expr(new kmp_literal_trait(2));
  group->set_negated(true);
 
  // Mock: 4 devices
  group->set_num_devices([]() { return 4; });
 
  // Without negation: matches 2
  // With negation: matches everything in-range except 2
  EXPECT_FALSE(group->match(2));
  EXPECT_TRUE(group->match(0));
  EXPECT_TRUE(group->match(1));
  EXPECT_TRUE(group->match(3));
  // Out of range devices return false regardless of negation
  EXPECT_FALSE(group->match(5));
 
  delete group;
}
 
TEST(kmp_trait_expr_group_test, MatchEmptyGroupOR) {
  kmp_trait_expr_group *group = new kmp_trait_expr_group();
  group->set_group_type(kmp_trait_expr_group::OR);
 
  // Mock: 4 devices
  group->set_num_devices([]() { return 4; });
 
  // Empty OR: no traits match, so result is false
  EXPECT_FALSE(group->match(0));
  EXPECT_FALSE(group->match(1));
 
  delete group;
}
 
TEST(kmp_trait_expr_group_test, MatchEmptyGroupAND) {
  kmp_trait_expr_group *group = new kmp_trait_expr_group();
  group->set_group_type(kmp_trait_expr_group::AND);
 
  // Mock: 4 devices
  group->set_num_devices([]() { return 4; });
 
  // Empty AND: vacuously true (0 out of 0 traits match)
  EXPECT_TRUE(group->match(0));
  EXPECT_TRUE(group->match(1));
 
  delete group;
}
 
TEST(kmp_trait_expr_group_test, Equality) {
  kmp_trait_expr_group *g1 = new kmp_trait_expr_group();
  kmp_trait_expr_group *g2 = new kmp_trait_expr_group();
 
  g1->add_expr(new kmp_literal_trait(1));
  g2->add_expr(new kmp_literal_trait(1));
 
  EXPECT_TRUE(*g1 == *g2);
 
  delete g1;
  delete g2;
}
 
TEST(kmp_trait_expr_group_test, EqualityDifferentNegation) {
  kmp_trait_expr_group *g1 = new kmp_trait_expr_group();
  kmp_trait_expr_group *g2 = new kmp_trait_expr_group();
 
  g1->add_expr(new kmp_literal_trait(1));
  g2->add_expr(new kmp_literal_trait(1));
  g2->set_negated(true);
 
  EXPECT_FALSE(*g1 == *g2);
 
  delete g1;
  delete g2;
}
 
TEST(kmp_trait_expr_group_test, EqualityDifferentGroupType) {
  // Groups with the same sub-expressions but different AND/OR type are not
  // equal.
  kmp_trait_expr_group *g1 = new kmp_trait_expr_group();
  kmp_trait_expr_group *g2 = new kmp_trait_expr_group();
 
  g1->add_expr(new kmp_literal_trait(1));
  g1->add_expr(new kmp_literal_trait(2));
  g1->set_group_type(kmp_trait_expr_group::AND);
  g2->add_expr(new kmp_literal_trait(1));
  g2->add_expr(new kmp_literal_trait(2));
  g2->set_group_type(kmp_trait_expr_group::OR);
 
  EXPECT_FALSE(*g1 == *g2);
 
  delete g1;
  delete g2;
}
 
TEST(kmp_trait_expr_group_test, NestedGroups) {
  kmp_trait_expr_group *outer = new kmp_trait_expr_group();
  outer->set_group_type(kmp_trait_expr_group::OR);
 
  kmp_trait_expr_group *inner = new kmp_trait_expr_group();
  inner->set_group_type(kmp_trait_expr_group::AND);
  inner->add_expr(new kmp_literal_trait(1));
  inner->add_expr(new kmp_wildcard_trait());
 
  outer->add_expr(inner);
  outer->add_expr(new kmp_literal_trait(2));
 
  // Mock: 4 devices
  outer->set_num_devices([]() { return 4; });
 
  // Inner matches device 1 (literal 1 AND wildcard)
  // Outer matches 1 OR 2
  EXPECT_TRUE(outer->match(1));
  EXPECT_TRUE(outer->match(2));
  EXPECT_FALSE(outer->match(0));
  EXPECT_FALSE(outer->match(3));
 
  delete outer;
}
 
//===----------------------------------------------------------------------===//
// kmp_trait_clause Tests
//===----------------------------------------------------------------------===//
 
TEST(kmp_trait_clause_test, CreateAndDestroy) {
  kmp_trait_clause *clause = new kmp_trait_clause();
  EXPECT_NE(clause, nullptr);
  delete clause;
}
 
TEST(kmp_trait_clause_test, SetExprWithTrait) {
  kmp_trait_clause *clause = new kmp_trait_clause();
  clause->set_expr(new kmp_literal_trait(2));
 
  // The trait is wrapped in kmp_trait_expr_single internally
  kmp_trait_expr *expr = clause->get_expr();
  EXPECT_NE(expr, nullptr);
 
  delete clause;
}
 
TEST(kmp_trait_clause_test, SetExprWithExpr) {
  kmp_trait_clause *clause = new kmp_trait_clause();
  kmp_trait_expr_group *group = new kmp_trait_expr_group();
  group->add_expr(new kmp_literal_trait(1));
  clause->set_expr(group);
 
  EXPECT_EQ(clause->get_expr(), group);
 
  delete clause;
}
 
TEST(kmp_trait_clause_test, Equality) {
  kmp_trait_clause *c1 = new kmp_trait_clause();
  kmp_trait_clause *c2 = new kmp_trait_clause();
 
  c1->set_expr(new kmp_literal_trait(1));
  c2->set_expr(new kmp_literal_trait(1));
 
  EXPECT_TRUE(*c1 == *c2);
 
  delete c1;
  delete c2;
}
 
TEST(kmp_trait_clause_test, EqualityDifferentExprs) {
  kmp_trait_clause *c1 = new kmp_trait_clause();
  kmp_trait_clause *c2 = new kmp_trait_clause();
 
  c1->set_expr(new kmp_literal_trait(1));
  c2->set_expr(new kmp_literal_trait(2));
 
  EXPECT_FALSE(*c1 == *c2);
 
  delete c1;
  delete c2;
}
 
//===----------------------------------------------------------------------===//
// kmp_trait_context Tests
//===----------------------------------------------------------------------===//
 
TEST(kmp_trait_context_test, CreateAndDestroy) {
  kmp_trait_context *context = new kmp_trait_context();
  EXPECT_NE(context, nullptr);
  delete context;
}
 
TEST(kmp_trait_context_test, AddClause) {
  kmp_trait_context *context = new kmp_trait_context();
  kmp_trait_clause *clause = new kmp_trait_clause();
  clause->set_expr(new kmp_literal_trait(2));
  context->add_clause(clause);
 
  // Mock: 4 devices
  context->set_num_devices([]() { return 4; });
 
  EXPECT_TRUE(context->match(2));
  EXPECT_FALSE(context->match(0));
  // Out of range
  EXPECT_FALSE(context->match(5));
 
  delete context;
}
 
TEST(kmp_trait_context_test, MultipleClauses) {
  kmp_trait_context *context = new kmp_trait_context();
 
  kmp_trait_clause *c1 = new kmp_trait_clause();
  c1->set_expr(new kmp_literal_trait(1));
  context->add_clause(c1);
 
  kmp_trait_clause *c2 = new kmp_trait_clause();
  c2->set_expr(new kmp_literal_trait(2));
  context->add_clause(c2);
 
  kmp_trait_clause *c3 = new kmp_trait_clause();
  c3->set_expr(new kmp_literal_trait(3));
  context->add_clause(c3);
 
  // Mock: 5 devices
  context->set_num_devices([]() { return 5; });
 
  // Context uses OR semantics between clauses
  EXPECT_TRUE(context->match(1));
  EXPECT_TRUE(context->match(2));
  EXPECT_TRUE(context->match(3));
  EXPECT_FALSE(context->match(0));
  EXPECT_FALSE(context->match(4));
 
  delete context;
}
 
TEST(kmp_trait_context_test, EmptyContextMatchesNothing) {
  kmp_trait_context *context = new kmp_trait_context();
 
  // Mock: 4 devices
  context->set_num_devices([]() { return 4; });
 
  EXPECT_FALSE(context->match(0));
  EXPECT_FALSE(context->match(1));
 
  delete context;
}
 
TEST(kmp_trait_context_test, WildcardClause) {
  kmp_trait_context *context = new kmp_trait_context();
  kmp_trait_clause *clause = new kmp_trait_clause();
  clause->set_expr(new kmp_wildcard_trait());
  context->add_clause(clause);
 
  // Mock: 4 devices
  context->set_num_devices([]() { return 4; });
 
  // In-range devices match
  EXPECT_TRUE(context->match(0));
  EXPECT_TRUE(context->match(3));
  // Out of range devices return false
  EXPECT_FALSE(context->match(100));
  EXPECT_FALSE(context->match(-1));
 
  delete context;
}
 
TEST(kmp_trait_context_test, EvaluateWithMock) {
  kmp_trait_context *context = new kmp_trait_context();
 
  // Mock: 5 devices
  context->set_num_devices([]() { return 5; });
 
  kmp_trait_clause *c1 = new kmp_trait_clause();
  c1->set_expr(new kmp_literal_trait(1));
  context->add_clause(c1);
 
  kmp_trait_clause *c2 = new kmp_trait_clause();
  c2->set_expr(new kmp_literal_trait(3));
  context->add_clause(c2);
 
  kmp_vector<int> result = context->evaluate();
  EXPECT_EQ(result.size(), 2u);
  EXPECT_TRUE(result.contains(1));
  EXPECT_TRUE(result.contains(3));
  EXPECT_FALSE(result.contains(0));
  EXPECT_FALSE(result.contains(2));
  EXPECT_FALSE(result.contains(4));
 
  delete context;
}
 
TEST(kmp_trait_context_test, Equality) {
  kmp_trait_context *ctx1 = new kmp_trait_context();
  kmp_trait_context *ctx2 = new kmp_trait_context();
 
  kmp_trait_clause *c1 = new kmp_trait_clause();
  c1->set_expr(new kmp_literal_trait(1));
  ctx1->add_clause(c1);
 
  kmp_trait_clause *c2 = new kmp_trait_clause();
  c2->set_expr(new kmp_literal_trait(1));
  ctx2->add_clause(c2);
 
  EXPECT_TRUE(*ctx1 == *ctx2);
 
  delete ctx1;
  delete ctx2;
}
 
TEST(kmp_trait_context_test, EqualityDifferentClauses) {
  kmp_trait_context *ctx1 = new kmp_trait_context();
  kmp_trait_context *ctx2 = new kmp_trait_context();
 
  kmp_trait_clause *c1 = new kmp_trait_clause();
  c1->set_expr(new kmp_literal_trait(1));
  ctx1->add_clause(c1);
 
  kmp_trait_clause *c2 = new kmp_trait_clause();
  c2->set_expr(new kmp_literal_trait(2));
  ctx2->add_clause(c2);
 
  EXPECT_FALSE(*ctx1 == *ctx2);
 
  delete ctx1;
  delete ctx2;
}
 
//===----------------------------------------------------------------------===//
// kmp_trait_context Iterator Tests
//===----------------------------------------------------------------------===//
 
TEST(kmp_trait_context_test, IteratorRangeBasedFor) {
  kmp_trait_context *context = new kmp_trait_context();
 
  // Mock: 5 devices
  context->set_num_devices([]() { return 5; });
 
  kmp_trait_clause *c1 = new kmp_trait_clause();
  c1->set_expr(new kmp_literal_trait(1));
  context->add_clause(c1);
 
  kmp_trait_clause *c2 = new kmp_trait_clause();
  c2->set_expr(new kmp_literal_trait(3));
  context->add_clause(c2);
 
  // Use range-based for loop (should auto-evaluate)
  kmp_vector<int> collected;
  for (int d : *context) {
    collected.push_back(d);
  }
 
  EXPECT_EQ(collected.size(), 2u);
  EXPECT_TRUE(collected.contains(1));
  EXPECT_TRUE(collected.contains(3));
 
  delete context;
}
 
TEST(kmp_trait_context_test, IteratorAutoEvaluates) {
  kmp_trait_context *context = new kmp_trait_context();
 
  // Mock: 4 devices
  context->set_num_devices([]() { return 4; });
 
  kmp_trait_clause *clause = new kmp_trait_clause();
  clause->set_expr(new kmp_wildcard_trait());
  context->add_clause(clause);
 
  // Directly use begin()/end() without calling evaluate() first
  int count = 0;
  for (const int *it = context->begin(); it != context->end(); ++it) {
    EXPECT_GE(*it, 0);
    EXPECT_LT(*it, 4);
    count++;
  }
 
  EXPECT_EQ(count, 4);
 
  delete context;
}
 
TEST(kmp_trait_context_test, IteratorEmptyContext) {
  kmp_trait_context *context = new kmp_trait_context();
 
  // Mock: 4 devices
  context->set_num_devices([]() { return 4; });
 
  // Empty context - no clauses added
  int count = 0;
  for (int d : *context) {
    (void)d;
    count++;
  }
 
  EXPECT_EQ(count, 0);
  EXPECT_EQ(context->begin(), context->end());
 
  delete context;
}
 
TEST(kmp_trait_context_test, IteratorBeginEnd) {
  kmp_trait_context *context = new kmp_trait_context();
 
  // Mock: 3 devices
  context->set_num_devices([]() { return 3; });
 
  kmp_trait_clause *clause = new kmp_trait_clause();
  clause->set_expr(new kmp_literal_trait(2));
  context->add_clause(clause);
 
  // Test begin/end directly
  const int *b = context->begin();
  const int *e = context->end();
 
  EXPECT_EQ(e - b, 1); // Should have exactly 1 element
  EXPECT_EQ(*b, 2);
 
  delete context;
}
 
TEST(kmp_trait_context_test, IteratorMultipleDevices) {
  kmp_trait_context *context = new kmp_trait_context();
 
  // Add clauses for devices 0, 2, 4
  for (int i = 0; i < 6; i += 2) {
    kmp_trait_clause *clause = new kmp_trait_clause();
    clause->set_expr(new kmp_literal_trait(i));
    context->add_clause(clause);
  }
 
  // Mock: 6 devices (must be set after adding clauses to propagate to them)
  context->set_num_devices([]() { return 6; });
 
  // Collect via iterator
  kmp_vector<int> collected;
  for (int d : *context) {
    collected.push_back(d);
  }
 
  EXPECT_EQ(collected.size(), 3u);
  EXPECT_TRUE(collected.contains(0));
  EXPECT_TRUE(collected.contains(2));
  EXPECT_TRUE(collected.contains(4));
 
  delete context;
}
 
TEST(kmp_trait_context_test, IteratorConsistentWithEvaluate) {
  kmp_trait_context *context = new kmp_trait_context();
 
  // Mock: 5 devices
  context->set_num_devices([]() { return 5; });
 
  kmp_trait_clause *c1 = new kmp_trait_clause();
  c1->set_expr(new kmp_literal_trait(1));
  context->add_clause(c1);
 
  kmp_trait_clause *c2 = new kmp_trait_clause();
  c2->set_expr(new kmp_literal_trait(4));
  context->add_clause(c2);
 
  // Get result via evaluate()
  const kmp_vector<int> &eval_result = context->evaluate();
 
  // Collect via iterator
  kmp_vector<int> iter_result;
  for (int d : *context) {
    iter_result.push_back(d);
  }
 
  // Both should give the same results
  EXPECT_EQ(eval_result.size(), iter_result.size());
  for (size_t i = 0; i < eval_result.size(); i++) {
    EXPECT_EQ(eval_result[i], iter_result[i]);
  }
 
  delete context;
}
 
TEST(kmp_trait_context_test, EvaluateReturnsByReference) {
  kmp_trait_context *context = new kmp_trait_context();
 
  // Mock: 3 devices
  context->set_num_devices([]() { return 3; });
 
  kmp_trait_clause *clause = new kmp_trait_clause();
  clause->set_expr(new kmp_wildcard_trait());
  context->add_clause(clause);
 
  // Multiple calls to evaluate() should return reference to the same data
  const kmp_vector<int> &result1 = context->evaluate();
  const kmp_vector<int> &result2 = context->evaluate();
 
  EXPECT_EQ(&result1, &result2);
 
  delete context;
}
 
//===----------------------------------------------------------------------===//
// get_num_devices Propagation Tests
//===----------------------------------------------------------------------===//
 
TEST(kmp_trait_context_test, PropagationToClausesAddedAfterSetNumDevices) {
  kmp_trait_context *context = new kmp_trait_context();
 
  // Set mock BEFORE adding clauses - propagation should still work
  context->set_num_devices([]() { return 6; });
 
  // Add clauses for devices 0, 2, 4 (all require 6 devices to be in range)
  for (int i = 0; i < 6; i += 2) {
    kmp_trait_clause *clause = new kmp_trait_clause();
    clause->set_expr(new kmp_literal_trait(i));
    context->add_clause(clause);
  }
 
  // All three devices should match because propagation worked
  kmp_vector<int> collected;
  for (int d : *context) {
    collected.push_back(d);
  }
 
  EXPECT_EQ(collected.size(), 3u);
  EXPECT_TRUE(collected.contains(0));
  EXPECT_TRUE(collected.contains(2));
  EXPECT_TRUE(collected.contains(4));
 
  delete context;
}
 
TEST(kmp_trait_context_test, PropagationToClausesAddedBeforeSetNumDevices) {
  kmp_trait_context *context = new kmp_trait_context();
 
  // Add clauses BEFORE setting mock
  for (int i = 0; i < 6; i += 2) {
    kmp_trait_clause *clause = new kmp_trait_clause();
    clause->set_expr(new kmp_literal_trait(i));
    context->add_clause(clause);
  }
 
  // Set mock AFTER adding clauses
  context->set_num_devices([]() { return 6; });
 
  // All three devices should match
  kmp_vector<int> collected;
  for (int d : *context) {
    collected.push_back(d);
  }
 
  EXPECT_EQ(collected.size(), 3u);
  EXPECT_TRUE(collected.contains(0));
  EXPECT_TRUE(collected.contains(2));
  EXPECT_TRUE(collected.contains(4));
 
  delete context;
}
 
TEST(kmp_trait_expr_group_test, PropagationToExprsAddedAfterSetNumDevices) {
  kmp_trait_expr_group *group = new kmp_trait_expr_group();
 
  // Set mock BEFORE adding expressions
  group->set_num_devices([]() { return 8; });
 
  // Add expressions for devices 5, 6, 7 (require 8 devices)
  group->add_expr(new kmp_literal_trait(5));
  group->add_expr(new kmp_literal_trait(6));
  group->add_expr(new kmp_literal_trait(7));
 
  // All should match
  EXPECT_TRUE(group->match(5));
  EXPECT_TRUE(group->match(6));
  EXPECT_TRUE(group->match(7));
  EXPECT_FALSE(group->match(4));
 
  delete group;
}
 
TEST(kmp_trait_expr_group_test, PropagationToExprsAddedBeforeSetNumDevices) {
  kmp_trait_expr_group *group = new kmp_trait_expr_group();
 
  // Add expressions BEFORE setting mock
  group->add_expr(new kmp_literal_trait(5));
  group->add_expr(new kmp_literal_trait(6));
  group->add_expr(new kmp_literal_trait(7));
 
  // Set mock AFTER adding expressions
  group->set_num_devices([]() { return 8; });
 
  // All should match
  EXPECT_TRUE(group->match(5));
  EXPECT_TRUE(group->match(6));
  EXPECT_TRUE(group->match(7));
  EXPECT_FALSE(group->match(4));
 
  delete group;
}
 
TEST(kmp_trait_expr_group_test, PropagationToNestedGroups) {
  kmp_trait_expr_group *outer = new kmp_trait_expr_group();
  outer->set_group_type(kmp_trait_expr_group::OR);
 
  // Set mock on outer group FIRST
  outer->set_num_devices([]() { return 10; });
 
  // Create inner group and add high-numbered devices
  kmp_trait_expr_group *inner = new kmp_trait_expr_group();
  inner->set_group_type(kmp_trait_expr_group::OR);
  inner->add_expr(new kmp_literal_trait(8));
  inner->add_expr(new kmp_literal_trait(9));
 
  // Add inner to outer - should propagate mock to inner and its children
  outer->add_expr(inner);
 
  // Add another expression directly to outer
  outer->add_expr(new kmp_literal_trait(7));
 
  // All should match with 10 devices
  EXPECT_TRUE(outer->match(7));
  EXPECT_TRUE(outer->match(8));
  EXPECT_TRUE(outer->match(9));
  EXPECT_FALSE(outer->match(10)); // Out of range
 
  delete outer;
}
 
TEST(kmp_trait_expr_group_test, PropagationToDeeplyNestedGroups) {
  // Create a deeply nested structure: outer -> middle -> inner
  kmp_trait_expr_group *outer = new kmp_trait_expr_group();
  outer->set_group_type(kmp_trait_expr_group::OR);
 
  // Set mock on outer
  outer->set_num_devices([]() { return 12; });
 
  kmp_trait_expr_group *middle = new kmp_trait_expr_group();
  middle->set_group_type(kmp_trait_expr_group::OR);
 
  kmp_trait_expr_group *inner = new kmp_trait_expr_group();
  inner->set_group_type(kmp_trait_expr_group::OR);
  inner->add_expr(new kmp_literal_trait(10));
  inner->add_expr(new kmp_literal_trait(11));
 
  middle->add_expr(inner);
  middle->add_expr(new kmp_literal_trait(9));
 
  outer->add_expr(middle);
  outer->add_expr(new kmp_literal_trait(8));
 
  // All devices 8-11 should match (requires 12 devices)
  EXPECT_TRUE(outer->match(8));
  EXPECT_TRUE(outer->match(9));
  EXPECT_TRUE(outer->match(10));
  EXPECT_TRUE(outer->match(11));
  EXPECT_FALSE(outer->match(12)); // Out of range
 
  delete outer;
}
 
TEST(kmp_trait_context_test, PropagationToNestedGroupsInClauses) {
  kmp_trait_context *context = new kmp_trait_context();
 
  // Set mock on context FIRST
  context->set_num_devices([]() { return 10; });
 
  // Create a group with nested structure
  kmp_trait_expr_group *group = new kmp_trait_expr_group();
  group->set_group_type(kmp_trait_expr_group::OR);
 
  kmp_trait_expr_group *inner = new kmp_trait_expr_group();
  inner->set_group_type(kmp_trait_expr_group::OR);
  inner->add_expr(new kmp_literal_trait(8));
  inner->add_expr(new kmp_literal_trait(9));
 
  group->add_expr(inner);
  group->add_expr(new kmp_literal_trait(7));
 
  // Create clause with the group
  kmp_trait_clause *clause = new kmp_trait_clause();
  clause->set_expr(group);
 
  // Add clause to context - should propagate to group and inner
  context->add_clause(clause);
 
  // All should match
  kmp_vector<int> collected;
  for (int d : *context) {
    collected.push_back(d);
  }
 
  EXPECT_EQ(collected.size(), 3u);
  EXPECT_TRUE(collected.contains(7));
  EXPECT_TRUE(collected.contains(8));
  EXPECT_TRUE(collected.contains(9));
 
  delete context;
}
 
TEST(kmp_trait_context_test, PropagationMixedOrder) {
  // Test a complex scenario with mixed ordering
  kmp_trait_context *context = new kmp_trait_context();
 
  // Add first clause before set_num_devices
  kmp_trait_clause *c1 = new kmp_trait_clause();
  c1->set_expr(new kmp_literal_trait(5));
  context->add_clause(c1);
 
  // Set mock
  context->set_num_devices([]() { return 8; });
 
  // Add second clause after set_num_devices
  kmp_trait_clause *c2 = new kmp_trait_clause();
  c2->set_expr(new kmp_literal_trait(6));
  context->add_clause(c2);
 
  // Add third clause with a group
  kmp_trait_expr_group *group = new kmp_trait_expr_group();
  group->add_expr(new kmp_literal_trait(7));
 
  kmp_trait_clause *c3 = new kmp_trait_clause();
  c3->set_expr(group);
  context->add_clause(c3);
 
  // All three should match
  kmp_vector<int> collected;
  for (int d : *context) {
    collected.push_back(d);
  }
 
  EXPECT_EQ(collected.size(), 3u);
  EXPECT_TRUE(collected.contains(5));
  EXPECT_TRUE(collected.contains(6));
  EXPECT_TRUE(collected.contains(7));
 
  delete context;
}
 
} // namespace