// Test program for bool_set.
//
// Copyright 2005, 2006, INRIA, France.
// All rights reserved.
//
// Author : Sylvain Pion, Herve Bronnimann, Guillaume Melquiond.

#include <iostream>
#include <cassert>
#include "bool_set.h"

using std::cout;
using namespace std2;

// Returns true if the conversion of i to bool throws.
bool throws(bool_set i)
{
  try {
    (bool) i;
    return false;
  }
  catch (...) {
    return true;
  }
}


int main()
{
  // Constructors
  cout << "Constructors...\n";
  bool_set t(true), f(false), i(bool_set::indeterminate()), e(bool_set::emptyset());
  bool_set ff, tt(t), ee(e), ii(i);
  
  // Member functions
  cout << "Member functions...\n";
  assert( t.equals(true) );
  assert( f.equals(false) );
  assert( ff.equals(false) );
  assert( ff.equals(f) );
  assert( i.equals(bool_set::indeterminate()) );
  assert( e.equals(bool_set::emptyset()) );

  assert( ! t.equals(f) );
  assert( ! t.equals(i) );
  assert( ! t.equals(e) );
  assert( ! f.equals(t) );
  assert( ! f.equals(i) );
  assert( ! f.equals(e) );
  assert( ! i.equals(t) );
  assert( ! i.equals(f) );
  assert( ! i.equals(e) );
  assert( ! e.equals(t) );
  assert( ! e.equals(f) );
  assert( ! e.equals(i) );
  
  assert( ! e.contains(t) );
  assert( ! e.contains(f) );
  assert( ! e.contains(i) );
  assert(   e.contains(e) );
  assert(   t.contains(t) );
  assert( ! t.contains(f) );
  assert( ! t.contains(i) );
  assert(   t.contains(e) );
  assert( ! f.contains(t) );
  assert(   f.contains(f) );
  assert( ! f.contains(i) );
  assert(   f.contains(e) );
  assert(   i.contains(t) );
  assert(   i.contains(f) );
  assert(   i.contains(i) );
  assert(   i.contains(e) );

  assert( ! t.is_emptyset() );
  assert( ! f.is_emptyset() );
  assert( ! i.is_emptyset() );
  assert(   e.is_emptyset() );
  
  assert( ! t.is_indeterminate() );
  assert( ! f.is_indeterminate() );
  assert(   i.is_indeterminate() );
  assert( ! e.is_indeterminate() );

  assert(   t.is_singleton() );
  assert(   f.is_singleton() );
  assert( ! i.is_singleton() );
  assert( ! e.is_singleton() );  
  
  // Free functions
  cout << "Free functions...\n";
  assert( equals( t, true) );
  assert( equals( f, false) );
  assert( equals( ff, false) );
  assert( equals( ff, f) );
  assert( equals( i, bool_set::indeterminate()) );
  assert( equals( e, bool_set::emptyset()) );
  
  assert( ! equals( t, f) );
  assert( ! equals( t, i) );
  assert( ! equals( t, e) );
  assert( ! equals( f, t) );
  assert( ! equals( f, i) );
  assert( ! equals( f, e) );
  assert( ! equals( i, t) );
  assert( ! equals( i, f) );
  assert( ! equals( i, e) );
      
  assert( ! contains( e, t) );
  assert( ! contains( e, f) );
  assert( ! contains( e, i) );
  assert(   contains( e, e) );
  assert(   contains( t, t) );
  assert( ! contains( t, f) );
  assert( ! contains( t, i) );
  assert(   contains( t, e) );
  assert( ! contains( f, t) );
  assert(   contains( f, f) );
  assert( ! contains( f, i) );
  assert(   contains( f, e) );
  assert(   contains( i, t) );
  assert(   contains( i, f) );
  assert(   contains( i, i) );
  assert(   contains( i, e) );
  
  assert( ! is_emptyset(t) );
  assert( ! is_emptyset(f) );
  assert( ! is_emptyset(i) );
  assert(   is_emptyset(e) );
  
  assert( ! is_indeterminate(t) );
  assert( ! is_indeterminate(f) );
  assert(   is_indeterminate(i) );
  assert( ! is_indeterminate(e) );
  
  assert(   is_singleton(t) );
  assert(   is_singleton(f) );
  assert( ! is_singleton(i) );
  assert( ! is_singleton(e) );  
  
  assert( ! certainly(e) );
  assert(   certainly(t) );
  assert( ! certainly(f) );
  assert( ! certainly(i) );
  assert( ! possibly(e) );
  assert(   possibly(t) );
  assert( ! possibly(f) );
  assert(   possibly(i) );
  
  // operators == and !=
  cout << "Operators == and !=...\n";
  assert( t == true );
  assert( f != true );
  assert( t != false );
  assert( f == false );
  assert( is_indeterminate( i == ii ) );
  assert( is_indeterminate( i != ii ) );
  assert( is_emptyset( e == ee ) );
  assert( is_emptyset( e != ee ) );
  assert( is_indeterminate( t == i ) );
  assert( is_indeterminate( f == i ) );
  assert( is_emptyset( t == e ) );
  assert( is_emptyset( f == e ) );
  assert( is_emptyset( i == e ) );

  assert( throws(e) );
  assert( throws(i) );
  
  // Set operations
  cout << "Set operations...\n";
  assert( equals( set_complement(e), i) );
  assert( equals( set_complement(t), f) );
  assert( equals( set_complement(f), t) );
  assert( equals( set_complement(i), e) );

  assert( equals( set_union(e, e), e) );
  assert( equals( set_union(e, t), t) );
  assert( equals( set_union(e, f), f) );
  assert( equals( set_union(e, i), i) );
  assert( equals( set_union(t, e), t) );
  assert( equals( set_union(t, t), t) );
  assert( equals( set_union(t, f), i) );
  assert( equals( set_union(t, i), i) );
  assert( equals( set_union(f, e), f) );
  assert( equals( set_union(f, t), i) );
  assert( equals( set_union(f, f), f) );
  assert( equals( set_union(f, i), i) );
  assert( equals( set_union(i, e), i) );
  assert( equals( set_union(i, t), i) );
  assert( equals( set_union(i, f), i) );
  assert( equals( set_union(i, i), i) );
    
  assert( equals( set_intersection(e, e), e) );
  assert( equals( set_intersection(e, t), e) );
  assert( equals( set_intersection(e, f), e) );
  assert( equals( set_intersection(e, i), e) );
  assert( equals( set_intersection(t, e), e) );
  assert( equals( set_intersection(t, t), t) );
  assert( equals( set_intersection(t, f), e) );
  assert( equals( set_intersection(t, i), t) );
  assert( equals( set_intersection(f, e), e) );
  assert( equals( set_intersection(f, t), e) );
  assert( equals( set_intersection(f, f), f) );
  assert( equals( set_intersection(f, i), f) );
  assert( equals( set_intersection(i, e), e) );
  assert( equals( set_intersection(i, t), t) );
  assert( equals( set_intersection(i, f), f) );
  assert( equals( set_intersection(i, i), i) );

  // operator !
  assert( equals(!f, true) );
  assert( equals(!t, false) );
  assert( equals(!e, bool_set::emptyset() ) );
  assert( equals(!i, bool_set::indeterminate()) );

  // Boolean logical operators are overloaded.
  cout << "Boolean logical operators...\n";
  
  assert( equals( (e || e), e) );
  assert( equals( (e || t), e) );
  assert( equals( (e || f), e) );
  assert( equals( (e || i), e) );
  assert( equals( (t || e), e) );
  assert( equals( (t || t), t) );
  assert( equals( (t || f), t) );
  assert( equals( (t || i), t) );
  assert( equals( (f || e), e) );
  assert( equals( (f || t), t) );
  assert( equals( (f || f), f) );
  assert( equals( (f || i), i) );
  assert( equals( (i || e), e) );
  assert( equals( (i || t), t) );
  assert( equals( (i || f), i) );
  assert( equals( (i || i), i) );
  
  assert( equals( (e && e), e) );
  assert( equals( (e && t), e) );
  assert( equals( (e && f), e) );
  assert( equals( (e && i), e) );
  assert( equals( (t && e), e) );
  assert( equals( (t && t), t) );
  assert( equals( (t && f), f) );
  assert( equals( (t && i), i) );
  assert( equals( (f && e), e) );
  assert( equals( (f && t), f) );
  assert( equals( (f && f), f) );
  assert( equals( (f && i), f) );
  assert( equals( (i && e), e) );
  assert( equals( (i && t), i) );
  assert( equals( (i && f), f) );
  assert( equals( (i && i), i) );
  
  // Logical operators are overloaded.
  cout << "Logical operators...\n";
  assert( equals( (e ^ e), e) );
  assert( equals( (e ^ t), e) );
  assert( equals( (e ^ f), e) );
  assert( equals( (e ^ i), e) );
  assert( equals( (t ^ e), e) );
  assert( equals( (t ^ t), f) );
  assert( equals( (t ^ f), t) );
  assert( equals( (t ^ i), i) );
  assert( equals( (f ^ e), e) );
  assert( equals( (f ^ t), t) );
  assert( equals( (f ^ f), f) );
  assert( equals( (f ^ i), i) );
  assert( equals( (i ^ e), e) );
  assert( equals( (i ^ t), i) );
  assert( equals( (i ^ f), i) );
  assert( equals( (i ^ i), i) );
  
  assert( equals( (e | e), e) );
  assert( equals( (e | t), e) );
  assert( equals( (e | f), e) );
  assert( equals( (e | i), e) );
  assert( equals( (t | e), e) );
  assert( equals( (t | t), t) );
  assert( equals( (t | f), t) );
  assert( equals( (t | i), t) );
  assert( equals( (f | e), e) );
  assert( equals( (f | t), t) );
  assert( equals( (f | f), f) );
  assert( equals( (f | i), i) );
  assert( equals( (i | e), e) );
  assert( equals( (i | t), t) );
  assert( equals( (i | f), i) );
  assert( equals( (i | i), i) );
                            
  assert( equals( (e & e), e) );
  assert( equals( (e & t), e) );
  assert( equals( (e & f), e) );
  assert( equals( (e & i), e) );
  assert( equals( (t & e), e) );
  assert( equals( (t & t), t) );
  assert( equals( (t & f), f) );
  assert( equals( (t & i), i) );
  assert( equals( (f & e), e) );
  assert( equals( (f & t), f) );
  assert( equals( (f & f), f) );
  assert( equals( (f & i), f) );
  assert( equals( (i & e), e) );
  assert( equals( (i & t), i) );
  assert( equals( (i & f), f) );
  assert( equals( (i & i), i) );
  
  return 0;
}