UnitTestSelector.cpp

/*------------------------------------------------------------------------*/
/*                 Copyright 2010 Sandia Corporation.                     */
/*  Under terms of Contract DE-AC04-94AL85000, there is a non-exclusive   */
/*  license for use of this work by or on behalf of the U.S. Government.  */
/*  Export of this program may require a license from the                 */
/*  United States Government.                                             */
/*------------------------------------------------------------------------*/


#include <stdexcept>
#include <stk_util/unit_test_support/stk_utest_macros.hpp>

#include <stk_mesh/base/Selector.hpp>
#include <stk_mesh/base/Bucket.hpp>
#include <stk_mesh/base/Part.hpp>
#include <stk_mesh/base/Types.hpp>
#include <stk_mesh/base/GetBuckets.hpp>
#include <stk_util/environment/WallTime.hpp>

#include <stk_util/parallel/Parallel.hpp>

#include <stk_mesh/fixtures/SelectorFixture.hpp>

// Unit test the Selector in isolation

namespace {

using stk_classic::mesh::fixtures::SelectorFixture ;

void initialize(SelectorFixture& fixture)
{
  fixture.m_meta_data.commit();
  fixture.m_bulk_data.modification_begin();
  fixture.generate_mesh();
  STKUNIT_ASSERT(fixture.m_bulk_data.modification_end());
}

STKUNIT_UNIT_TEST( UnitTestSelector, one_SelectorFixture )
{
  {
    SelectorFixture fix;
    initialize(fix);
  }
  STKUNIT_EXPECT_TRUE(true);
}


STKUNIT_UNIT_TEST( UnitTestSelector, two_SelectorFixture )
{
  {
    SelectorFixture fix;
    initialize(fix);
  }
  {
    SelectorFixture fix;
    initialize(fix);
  }
  STKUNIT_EXPECT_TRUE(true);
}



STKUNIT_UNIT_TEST( UnitTestSelector, A_12345 )
{
  SelectorFixture fix;
  initialize(fix);

  stk_classic::mesh::Selector selector( fix.m_partA );
  //std::cout << "Selector = " << selector << std::endl;

  {
    const stk_classic::mesh::Bucket & bucket = fix.m_entity1->bucket() ;
    bool result = selector(bucket);
    STKUNIT_EXPECT_TRUE(result);
  }
  {
    const stk_classic::mesh::Bucket & bucket = fix.m_entity2->bucket();
    bool result = selector(bucket);
    STKUNIT_EXPECT_TRUE(result);
  }
  {
    const stk_classic::mesh::Bucket & bucket = fix.m_entity3->bucket();
    bool result = selector(bucket);
    STKUNIT_EXPECT_FALSE(result);
  }
  {
    const stk_classic::mesh::Bucket & bucket = fix.m_entity4->bucket();
    bool result = selector(bucket);
    STKUNIT_EXPECT_FALSE(result);
  }
  {
    const stk_classic::mesh::Bucket & bucket = fix.m_entity5->bucket();
    bool result = selector(bucket);
    STKUNIT_EXPECT_FALSE(result);
  }
}

STKUNIT_UNIT_TEST( UnitTestSelector, Ac_12345 )
{
  SelectorFixture fix;
  initialize(fix);

  stk_classic::mesh::Selector selector = ! fix.m_partA ;
  //std::cout << "Selector = " << selector << std::endl;

  {
    const stk_classic::mesh::Bucket & bucket = fix.m_entity1->bucket();
    bool result = selector(bucket);
    STKUNIT_EXPECT_FALSE(result);
  }
  {
    const stk_classic::mesh::Bucket & bucket = fix.m_entity2->bucket();
    bool result = selector(bucket);
    STKUNIT_EXPECT_FALSE(result);
  }
  {
    const stk_classic::mesh::Bucket & bucket = fix.m_entity3->bucket();
    bool result = selector(bucket);
    STKUNIT_EXPECT_TRUE(result);
  }
  {
    const stk_classic::mesh::Bucket & bucket = fix.m_entity4->bucket();
    bool result = selector(bucket);
    STKUNIT_EXPECT_TRUE(result);
  }
  {
    const stk_classic::mesh::Bucket & bucket = fix.m_entity5->bucket();
    bool result = selector(bucket);
    STKUNIT_EXPECT_TRUE(result);
  }

}

STKUNIT_UNIT_TEST( UnitTestSelector, D_5 )
{
  SelectorFixture fix;
  initialize(fix);

  stk_classic::mesh::Selector selector( fix.m_partD );

  const stk_classic::mesh::Bucket & bucket = fix.m_entity5->bucket();

  bool result = selector(bucket);
  STKUNIT_EXPECT_FALSE(result);
}

STKUNIT_UNIT_TEST( UnitTestSelector, Ac_15 )
{
  SelectorFixture fix;
  initialize(fix);

  stk_classic::mesh::Part & partA = fix.m_partA ;

  stk_classic::mesh::Selector selector(partA);
  selector.complement();
  //std::cout << "Selector = " << selector << std::endl;

  {
    const stk_classic::mesh::Bucket & bucket = fix.m_entity1->bucket();
    bool result = selector(bucket);
    STKUNIT_EXPECT_FALSE(result);
  }
  {
    const stk_classic::mesh::Bucket & bucket = fix.m_entity5->bucket();
    bool result = selector(bucket);
    STKUNIT_EXPECT_TRUE(result);
  }
}

STKUNIT_UNIT_TEST( UnitTestSelector, AiB_12 )
{
  SelectorFixture fix ;
  initialize(fix);

  stk_classic::mesh::Part & partA = fix.m_partA ;
  stk_classic::mesh::Part & partB = fix.m_partB ;

  stk_classic::mesh::Selector selector = partA & partB;
  //std::cout << "Selector = " << selector << std::endl;

  {
    const stk_classic::mesh::Bucket & bucket = fix.m_entity1->bucket();
    bool result = selector(bucket);
    STKUNIT_EXPECT_FALSE(result);
  }
  {
    const stk_classic::mesh::Bucket & bucket = fix.m_entity2->bucket();
    bool result = selector(bucket);
    STKUNIT_EXPECT_TRUE(result);
  }
}


STKUNIT_UNIT_TEST( UnitTestSelector, AuB_14 )
{
  SelectorFixture fix ;
  initialize(fix);

  stk_classic::mesh::Part & partA = fix.m_partA ;
  stk_classic::mesh::Part & partB = fix.m_partB ;

  stk_classic::mesh::Selector selector = partA | partB;
  //std::cout << "Selector = " << selector << std::endl;

  {
    const stk_classic::mesh::Bucket & bucket = fix.m_entity1->bucket();
    bool result = selector(bucket);
    STKUNIT_EXPECT_TRUE(result);
  }
  {
    const stk_classic::mesh::Bucket & bucket = fix.m_entity4->bucket();
    bool result = selector(bucket);
    STKUNIT_EXPECT_FALSE(result);
  }
}


STKUNIT_UNIT_TEST( UnitTestSelector, AiBc_12 )
{
  SelectorFixture fix ;
  initialize(fix);

  stk_classic::mesh::Part & partA = fix.m_partA ;
  stk_classic::mesh::Part & partB = fix.m_partB ;

  stk_classic::mesh::Selector selector = partA & !partB;
  //std::cout << "Selector = " << selector << std::endl;

  {
    const stk_classic::mesh::Bucket & bucket = fix.m_entity1->bucket();
    bool result = selector(bucket);
    STKUNIT_EXPECT_TRUE(result);
  }
  {
    const stk_classic::mesh::Bucket & bucket = fix.m_entity2->bucket();
    bool result = selector(bucket);
    STKUNIT_EXPECT_FALSE(result);
  }
}


STKUNIT_UNIT_TEST( UnitTestSelector, AuBc_13 )
{
  SelectorFixture fix ;
  initialize(fix);

  stk_classic::mesh::Part & partA = fix.m_partA ;
  stk_classic::mesh::Part & partB = fix.m_partB ;

  stk_classic::mesh::Selector selector = partA | !partB;
  //std::cout << "Selector = " << selector << std::endl;

  {
    const stk_classic::mesh::Bucket & bucket = fix.m_entity1->bucket();
    bool result = selector(bucket);
    STKUNIT_EXPECT_TRUE(result);
  }
  {
    const stk_classic::mesh::Bucket & bucket = fix.m_entity3->bucket();
    bool result = selector(bucket);
    STKUNIT_EXPECT_FALSE(result);
  }
}


// plus copy constructor
STKUNIT_UNIT_TEST( UnitTestSelector, Ai_BuC_c_12 )
{
  SelectorFixture fix ;
  initialize(fix);

  stk_classic::mesh::Part & partA = fix.m_partA ;
  stk_classic::mesh::Part & partB = fix.m_partB ;
  stk_classic::mesh::Part & partC = fix.m_partC ;

  stk_classic::mesh::Selector selector = partA & !(partB | partC);
  //std::cout << "Selector = " << selector << std::endl;

  {
    const stk_classic::mesh::Bucket & bucket = fix.m_entity1->bucket();
    bool result = selector(bucket);
    STKUNIT_EXPECT_TRUE(result);
  }
  {
    const stk_classic::mesh::Bucket & bucket = fix.m_entity2->bucket();
    bool result = selector(bucket);
    STKUNIT_EXPECT_FALSE(result);
  }

  stk_classic::mesh::Selector newSelector(selector);
  // Should be the same:
  {
    const stk_classic::mesh::Bucket & bucket = fix.m_entity1->bucket();
    bool result = newSelector(bucket);
    STKUNIT_EXPECT_TRUE(result);
  }
  {
    const stk_classic::mesh::Bucket & bucket = fix.m_entity2->bucket();
    bool result = newSelector(bucket);
    STKUNIT_EXPECT_FALSE(result);
  }

}


STKUNIT_UNIT_TEST( UnitTestSelector, entityTest )
{
  {
    SelectorFixture fix ;
    initialize(fix);

    stk_classic::mesh::Part & partA = fix.m_partA ;
    stk_classic::mesh::Part & partB = fix.m_partB ;
    stk_classic::mesh::Selector selector = partA & !partB;

    const stk_classic::mesh::Entity & pEntity = *fix.m_entity5;
    bool result = selector(pEntity);
    STKUNIT_EXPECT_FALSE(result);
  }

}

STKUNIT_UNIT_TEST( UnitTestSelector, defaultConstructor )
{
  SelectorFixture fix ;
  initialize(fix);

  stk_classic::mesh::Selector selector;
  //std::cout << "Selector = " << selector << std::endl;

  {
    const stk_classic::mesh::Bucket & bucket = fix.m_entity1->bucket();
    bool result = selector(bucket);
    STKUNIT_EXPECT_FALSE(result);
  }
}


STKUNIT_UNIT_TEST( UnitTestSelector, flipComplement_AuB_c )
{
  SelectorFixture fix ;
  initialize(fix);

  stk_classic::mesh::Part & partA = fix.m_partA ;
  stk_classic::mesh::Part & partB = fix.m_partB ;
  stk_classic::mesh::Selector notOrSelector = partA | partB;
  //std::cout << "Or Selector = " << notOrSelector << std::endl;
  notOrSelector.complement();
  //std::cout << "Not Or Selector = " << notOrSelector << std::endl;

  {
    const stk_classic::mesh::Bucket & bucket = fix.m_entity1->bucket();
    bool result = notOrSelector(bucket);
    STKUNIT_EXPECT_FALSE(result);
  }
  {
    const stk_classic::mesh::Bucket & bucket = fix.m_entity2->bucket();
    bool result = notOrSelector(bucket);
    STKUNIT_EXPECT_FALSE(result);
  }
  {
    const stk_classic::mesh::Bucket & bucket = fix.m_entity3->bucket();
    bool result = notOrSelector(bucket);
    STKUNIT_EXPECT_FALSE(result);
  }
  {
    const stk_classic::mesh::Bucket & bucket = fix.m_entity4->bucket();
    bool result = notOrSelector(bucket);
    STKUNIT_EXPECT_TRUE(result);
  }

  stk_classic::mesh::Selector notNotOrSelector = !notOrSelector;
  //std::cout << "Not Not Or Selector = " << notNotOrSelector << std::endl;
  {
    const stk_classic::mesh::Bucket & bucket = fix.m_entity1->bucket();
    bool result = notNotOrSelector(bucket);
    STKUNIT_EXPECT_TRUE(result);
  }
  {
    const stk_classic::mesh::Bucket & bucket = fix.m_entity2->bucket();
    bool result = notNotOrSelector(bucket);
    STKUNIT_EXPECT_TRUE(result);
  }
  {
    const stk_classic::mesh::Bucket & bucket = fix.m_entity3->bucket();
    bool result = notNotOrSelector(bucket);
    STKUNIT_EXPECT_TRUE(result);
  }
  {
    const stk_classic::mesh::Bucket & bucket = fix.m_entity4->bucket();
    bool result = notNotOrSelector(bucket);
    STKUNIT_EXPECT_FALSE(result);
  }
}

STKUNIT_UNIT_TEST( UnitTestSelector, flipComplement_AiB_c )
{
  SelectorFixture fix ;
  initialize(fix);

  stk_classic::mesh::Part & partA = fix.m_partA ;
  stk_classic::mesh::Part & partB = fix.m_partB ;
  stk_classic::mesh::Selector notAndSelector = partA & partB;
  //std::cout << "And Selector = " << notAndSelector << std::endl;
  notAndSelector.complement();
  //std::cout << "Not And Selector = " << notAndSelector << std::endl;

  {
    const stk_classic::mesh::Bucket & bucket = fix.m_entity1->bucket();
    bool result = notAndSelector(bucket);
    STKUNIT_EXPECT_TRUE(result);
  }
  {
    const stk_classic::mesh::Bucket & bucket = fix.m_entity2->bucket();
    bool result = notAndSelector(bucket);
    STKUNIT_EXPECT_FALSE(result);
  }
  {
    const stk_classic::mesh::Bucket & bucket = fix.m_entity3->bucket();
    bool result = notAndSelector(bucket);
    STKUNIT_EXPECT_TRUE(result);
  }
  {
    const stk_classic::mesh::Bucket & bucket = fix.m_entity4->bucket();
    bool result = notAndSelector(bucket);
    STKUNIT_EXPECT_TRUE(result);
  }

  stk_classic::mesh::Selector notNotAndSelector = !notAndSelector;
  //std::cout << "Not Not And Selector = " << notNotAndSelector << std::endl;
  {
    const stk_classic::mesh::Bucket & bucket = fix.m_entity1->bucket();
    bool result = notNotAndSelector(bucket);
    STKUNIT_EXPECT_FALSE(result);
  }
  {
    const stk_classic::mesh::Bucket & bucket = fix.m_entity2->bucket();
    bool result = notNotAndSelector(bucket);
    STKUNIT_EXPECT_TRUE(result);
  }
  {
    const stk_classic::mesh::Bucket & bucket = fix.m_entity3->bucket();
    bool result = notNotAndSelector(bucket);
    STKUNIT_EXPECT_FALSE(result);
  }
  {
    const stk_classic::mesh::Bucket & bucket = fix.m_entity4->bucket();
    bool result = notNotAndSelector(bucket);
    STKUNIT_EXPECT_FALSE(result);
  }
}

STKUNIT_UNIT_TEST( UnitTestSelector, complementEmpty ) {
  SelectorFixture fix ;
  initialize(fix);

  stk_classic::mesh::Selector selector;
  {
    const stk_classic::mesh::Bucket & bucket = fix.m_entity1->bucket();
    bool result = selector(bucket);
    STKUNIT_EXPECT_FALSE(result);
  }
  selector.complement();
  {
    const stk_classic::mesh::Bucket & bucket = fix.m_entity1->bucket();
    bool result = selector(bucket);
    STKUNIT_EXPECT_TRUE(result);
  }
}


STKUNIT_UNIT_TEST( UnitTestSelector, AuBuCuD )
{
  SelectorFixture fix ;
  initialize(fix);

  stk_classic::mesh::Part & partA = fix.m_partA ;
  stk_classic::mesh::Part & partB = fix.m_partB ;
  stk_classic::mesh::Part & partC = fix.m_partC ;
  stk_classic::mesh::Part & partD = fix.m_partD ;
  stk_classic::mesh::Selector selector = partA | partB | partC | partD;
  std::cout << "A|B|C|D = " << selector << std::endl;
  std::ostringstream msg;
  msg << selector;
  STKUNIT_EXPECT_EQUAL( "!(!PartA AND !PartB AND !PartC AND !PartD)" , msg.str() );
}


STKUNIT_UNIT_TEST( UnitTestSelector, AiBiC )
{
  SelectorFixture fix ;
  initialize(fix);

  stk_classic::mesh::Part & partA = fix.m_partA ;
  stk_classic::mesh::Part & partB = fix.m_partB ;
  stk_classic::mesh::Part & partC = fix.m_partC ;
  stk_classic::mesh::Selector selector = partA & partB & partC;
  std::cout << "A&B&C = " << selector << std::endl;
  std::ostringstream msg;
  msg << selector;
  STKUNIT_EXPECT_TRUE( msg.str() == "PartA AND PartB AND PartC" );
}


STKUNIT_UNIT_TEST( UnitTestSelector, complicated )
{
  SelectorFixture fix ;
  initialize(fix);

  stk_classic::mesh::Part & partA = fix.m_partA ;
  stk_classic::mesh::Part & partB = fix.m_partB ;
  stk_classic::mesh::Part & partC = fix.m_partC ;
  stk_classic::mesh::Part & partD = fix.m_partD ;
  stk_classic::mesh::Selector selector =  partA | ( !((partA & partB) | partC)  & (!partD | partB));
  std::cout << "complicated selector = " << selector << std::endl;
  std::ostringstream msg;
  msg << selector;
  STKUNIT_EXPECT_EQUAL( "!(!PartA AND !((!(PartA AND PartB) AND !PartC) AND !(PartD AND !PartB)))" , msg.str() );
}


STKUNIT_UNIT_TEST( UnitTestSelector, selectIntersection )
{
  SelectorFixture fix ;
  initialize(fix);

  stk_classic::mesh::PartVector parts ;
  parts.push_back( & fix.m_partA );
  parts.push_back( & fix.m_partB );
  stk_classic::mesh::Selector selector = selectIntersection(parts);

  {
    const stk_classic::mesh::Bucket & bucket = fix.m_entity1->bucket();
    bool result = selector(bucket);
    STKUNIT_ASSERT_FALSE(result);
  }
  {
    const stk_classic::mesh::Bucket & bucket = fix.m_entity2->bucket();
    bool result = selector(bucket);
    STKUNIT_ASSERT_TRUE(result);
  }
  {
    const stk_classic::mesh::Bucket & bucket = fix.m_entity3->bucket();
    bool result = selector(bucket);
    STKUNIT_ASSERT_FALSE(result);
  }
  {
    const stk_classic::mesh::Bucket & bucket = fix.m_entity4->bucket();
    bool result = selector(bucket);
    STKUNIT_ASSERT_FALSE(result);
  }
  {
    const stk_classic::mesh::Bucket & bucket = fix.m_entity5->bucket();
    bool result = selector(bucket);
    STKUNIT_ASSERT_FALSE(result);
  }

  std::ostringstream msg;
  msg << selector;
  STKUNIT_EXPECT_TRUE( msg.str() == "PartA AND PartB");
}


STKUNIT_UNIT_TEST( UnitTestSelector, selectUnion )
{
  SelectorFixture fix ;
  initialize(fix);

  stk_classic::mesh::PartVector parts ;
  parts.push_back( & fix.m_partA );
  parts.push_back( & fix.m_partB );
  parts.push_back( & fix.m_partC );
  stk_classic::mesh::Selector selector = selectUnion(parts);

  {
    const stk_classic::mesh::Bucket & bucket = fix.m_entity1->bucket();
    bool result = selector(bucket);
    STKUNIT_ASSERT_TRUE(result);
  }
  {
    const stk_classic::mesh::Bucket & bucket = fix.m_entity2->bucket();
    bool result = selector(bucket);
    STKUNIT_ASSERT_TRUE(result);
  }
  {
    const stk_classic::mesh::Bucket & bucket = fix.m_entity3->bucket();
    bool result = selector(bucket);
    STKUNIT_ASSERT_TRUE(result);
  }
  {
    const stk_classic::mesh::Bucket & bucket = fix.m_entity4->bucket();
    bool result = selector(bucket);
    STKUNIT_ASSERT_TRUE(result);
  }
  {
    const stk_classic::mesh::Bucket & bucket = fix.m_entity5->bucket();
    bool result = selector(bucket);
    STKUNIT_ASSERT_FALSE(result);
  }

  std::ostringstream msg;
  msg << selector;
  std::cout << "msg.str() = " << msg.str() << std::endl;
  STKUNIT_EXPECT_EQUAL( "!(!PartA AND !PartB AND !PartC)", msg.str() );
}

// Intersection first then union
// & before |
//STKUNIT_UNIT_TEST( UnitTestSelector, orderOfOperations )
//{
//  SelectorFixture fix ;
//  stk_classic::mesh::Part & partA = fix.m_partA ;
//  stk_classic::mesh::Part & partB = fix.m_partB ;
//  stk_classic::mesh::Part & partC = fix.m_partC ;
//  {
//    stk_classic::mesh::Selector selector = partA | partB & partC;
//    //std::cout << "A|B&C selector = " << selector << std::endl;
//    std::ostringstream msg;
//    msg << selector;
//    STKUNIT_EXPECT_EQUAL( "!(!PartA AND !(PartB AND PartC))", msg.str() );
//    {
//      const stk_classic::mesh::Bucket & bucket = fix.m_entity1->bucket();
//      bool result = selector(bucket);
//      STKUNIT_EXPECT_TRUE(result);
//    }
//    {
//      const stk_classic::mesh::Bucket & bucket = fix.m_entity2->bucket();
//      bool result = selector(bucket);
//      STKUNIT_EXPECT_TRUE(result);
//    }
//    {
//      const stk_classic::mesh::Bucket & bucket = fix.m_entity3->bucket();
//      bool result = selector(bucket);
//      STKUNIT_EXPECT_TRUE(result);
//    }
//    {
//      const stk_classic::mesh::Bucket & bucket = fix.m_entity4->bucket();
//      bool result = selector(bucket);
//      STKUNIT_EXPECT_FALSE(result);
//    }
//  }
//  {
//    stk_classic::mesh::Selector selector = partB & partC | partA;
//    //std::cout << "B&C|A selector = " << selector << std::endl;
//    std::ostringstream msg;
//    msg << selector;
//    STKUNIT_EXPECT_EQUAL( "!(!(PartB AND PartC) AND !PartA)", msg.str() );
//    {
//      const stk_classic::mesh::Bucket & bucket = fix.m_entity1->bucket();
//      bool result = selector(bucket);
//      STKUNIT_EXPECT_TRUE(result);
//    }
//    {
//      const stk_classic::mesh::Bucket & bucket = fix.m_entity2->bucket();
//      bool result = selector(bucket);
//      STKUNIT_EXPECT_TRUE(result);
//    }
//    {
//      const stk_classic::mesh::Bucket & bucket = fix.m_entity3->bucket();
//      bool result = selector(bucket);
//      STKUNIT_EXPECT_TRUE(result);
//    }
//    {
//      const stk_classic::mesh::Bucket & bucket = fix.m_entity4->bucket();
//      bool result = selector(bucket);
//      STKUNIT_EXPECT_FALSE(result);
//    }
//  }
//}


STKUNIT_UNIT_TEST( UnitTestSelector, ZeroiuZero ) {
  SelectorFixture fix ;
  initialize(fix);

  stk_classic::mesh::Selector selectNone;
  stk_classic::mesh::Selector selectAll;
  selectAll.complement();
  {
    stk_classic::mesh::Selector selector = selectNone & selectAll;
    const stk_classic::mesh::Bucket & bucket = fix.m_entity1->bucket();
    bool result = selector(bucket);
    STKUNIT_EXPECT_FALSE(result);
  }
  {
    stk_classic::mesh::Selector selector = selectNone | selectAll;
    const stk_classic::mesh::Bucket & bucket = fix.m_entity1->bucket();
    bool result = selector(bucket);
    STKUNIT_EXPECT_TRUE(result);
  }

}

STKUNIT_UNIT_TEST( UnitTestSelector, ZeroiuA )
{
  SelectorFixture fix ;
  initialize(fix);

  stk_classic::mesh::Part & partA = fix.m_partA ;
  stk_classic::mesh::Selector selectNone;
  stk_classic::mesh::Selector selectAll;
  selectAll.complement();
  stk_classic::mesh::Selector selectA = partA;
  stk_classic::mesh::Selector selectNoneOrA = selectNone | selectA;
  stk_classic::mesh::Selector selectAllAndA = selectAll & selectA;
  {
    const stk_classic::mesh::Bucket & bucket = fix.m_entity1->bucket();
    bool result = selectNoneOrA(bucket);
    STKUNIT_EXPECT_TRUE(result);
  }
  {
    const stk_classic::mesh::Bucket & bucket = fix.m_entity1->bucket();
    bool result = selectAllAndA(bucket);
    STKUNIT_EXPECT_TRUE(result);
  }
}


STKUNIT_UNIT_TEST( UnitTestSelector, copyConstructor )
{
  SelectorFixture fix ;
  initialize(fix);

  stk_classic::mesh::Part & partA = fix.m_partA ;
  stk_classic::mesh::Part & partB = fix.m_partB ;
  stk_classic::mesh::Part & partC = fix.m_partC ;
  stk_classic::mesh::Selector selectA = (partA & partB) | partC;
  stk_classic::mesh::Selector anotherSelectA(selectA);
  std::ostringstream descriptionA;
  descriptionA << selectA;
  std::ostringstream descriptionAnotherA;
  descriptionAnotherA << anotherSelectA;
  STKUNIT_EXPECT_EQUAL( descriptionA.str() == descriptionAnotherA.str(), true );
}


STKUNIT_UNIT_TEST( UnitTestSelector, AlliuAll )
{
  stk_classic::mesh::Selector selectAll;
  selectAll.complement();

  stk_classic::mesh::Selector anotherSelectAll;
  anotherSelectAll.complement();

  {
    stk_classic::mesh::Selector selectAllANDAll = selectAll & anotherSelectAll;
    std::ostringstream description;
    description << selectAllANDAll;
    STKUNIT_EXPECT_EQUAL( "!() AND !()", description.str() );
  }
  {
    stk_classic::mesh::Selector selectAllORAll = selectAll | anotherSelectAll;
    std::ostringstream description;
    description << selectAllORAll;
    STKUNIT_EXPECT_EQUAL( "!(())", description.str() );
  }
}

STKUNIT_UNIT_TEST( UnitTestSelector, selectField )
{
  SelectorFixture fix ;
  initialize(fix);

  stk_classic::mesh::Selector selectA = stk_classic::mesh::selectField(fix.m_fieldA);
  stk_classic::mesh::Selector selectABC = stk_classic::mesh::selectField(fix.m_fieldABC);
  {
    //entity1 is in partA, so entity1's bucket should be selected by selectA:
    const stk_classic::mesh::Bucket & bucket = fix.m_entity1->bucket();
    bool result = selectA(bucket);
    STKUNIT_EXPECT_TRUE(result);
  }
  {
    //entity3 is not in partA, so entity3's bucket should not be selected by selectA:
    const stk_classic::mesh::Bucket & bucket = fix.m_entity3->bucket();
    bool result = selectA(bucket);
    STKUNIT_EXPECT_FALSE(result);
  }
  {
    //entity3 is in partB, so entity3's bucket should be selected by selectABC:
    const stk_classic::mesh::Bucket & bucket = fix.m_entity3->bucket();
    bool result = selectABC(bucket);
    STKUNIT_EXPECT_TRUE(result);
  }
}

STKUNIT_UNIT_TEST( UnitTestSelector, select_part )
{
  SelectorFixture fix ;
  initialize(fix);

  stk_classic::mesh::Part & partA = fix.m_partA ;
  stk_classic::mesh::Part & partB = fix.m_partB ;
  stk_classic::mesh::Part & partC = fix.m_partC ;
  stk_classic::mesh::Part & partD = fix.m_partD ;
  stk_classic::mesh::Selector selector =  partA | partB | (!partC) | partD;
  std::cout << "select_part selector = " << selector << std::endl;
  STKUNIT_EXPECT_TRUE(selector(partA));
  STKUNIT_EXPECT_TRUE(selector(partB));
  STKUNIT_EXPECT_FALSE(selector(partC));
  STKUNIT_EXPECT_TRUE(selector(partD));

  selector =  
    partA |  
    ( !( (partA & partB) | partC)  
      & 
      (!partD | partB)
      );

  STKUNIT_EXPECT_TRUE(selector(partA));
  STKUNIT_EXPECT_TRUE(selector(partB));
  STKUNIT_EXPECT_FALSE(selector(partC));
  STKUNIT_EXPECT_FALSE(selector(partD));

  selector = partC & (!partD);
  STKUNIT_EXPECT_FALSE(selector(partA));
  STKUNIT_EXPECT_FALSE(selector(partB));
  STKUNIT_EXPECT_TRUE(selector(partC));
  STKUNIT_EXPECT_FALSE(selector(partD));

}

} // namespace