class TestCase::Operator::IsType {
  use TestCase::Minimal;
  use TestCase::Simple;
  use Comparator;
  use Complex_2d;
  use Complex_2f;
  use Stringer;
  use Point;

  static method is_type : int () {
    
    # Numeric
    {
      {
        my $value : byte;
        
        unless ($value is_type byte) {
          return 0;
        }
        
        if ($value is_type short) {
          return 0;
        }
      }
      
      {
        my $value : double;
        
        unless ($value is_type double) {
          return 0;
        }
      }
    }
    
    # Multi-numeric
    {
      {
        my $value : Complex_2d;
        
        unless ($value is_type Complex_2d) {
          return 0;
        }
        
        if ($value is_type Complex_2f) {
          return 0;
        }
      }
    }
    
    # Any object array
    {
      {
        my $value = new object[0];
        
        unless ($value is_type object[]) {
          return 0;
        }
      }
      
      {
        my $value = (object)new object[0];
        
        unless ($value is_type object[]) {
          return 0;
        }
      }
      
      {
        my $value : object[];
        
        if ($value is_type object[]) {
          return 0;
        }
      }
      
      {
        my $value = Point->new;
        
        if ($value is_type object[]) {
          return 0;
        }
      }
      
      {
        my $value = new Point[0];
        
        if ($value is_type object[]) {
          return 0;
        }
      }
      
      {
        my $value = new Stringable[0];
        
        if ($value is_type object[]) {
          return 0;
        }
      }
      
      {
        my $value = new int[0];
        
        if ($value is_type object[]) {
          return 0;
        }
      }
      
    }
    
    # An object type
    {
      {
        my $value : Point = Point->new;
        
        unless ($value is_type Point) {
          return 0;
        }
      }
      
      {
        my $value : Point = Point->new;
        
        if ($value is_type Cloneable) {
          return 0;
        }
      }
      
      {
        my $value : Point;
        
        if ($value is_type Point) {
          return 0;
        }
      }
    }
    
    {
      my $object = TestCase::Minimal->new;
      unless ($object is_type TestCase::Minimal) {
        return 0;
      }
      
      my $object2 : object = $object;
      unless ($object2 is_type TestCase::Minimal) {
        return 0;
      }
    }
    
    {
      my $objects = new TestCase::Minimal[3];
      my $nums = new int[3];
      
      unless ($objects is_type TestCase::Minimal[]) {
        return 0;
      }
       
      unless ($nums is_type int[]) {
        return 0;
      }
    }
    
    {
      my $object = TestCase::Minimal->new;
      if ($object is_type TestCase::Simple) {
        return 0;
      }
    }
    
    {
      my $object : TestCase::Minimal = undef;
      
      if ($object is_type TestCase::Minimal) {
        return 0;
      }
    }
    
    {
      my $stringables = new Stringable[3];
      
      unless ($stringables is_type Stringable[]) {
        return 0;
      }
    }
    
    {
      my $object = Bool->TRUE;
      unless ($object is_type Bool) {
        return 0;
      }
    }
    
    {
      my $object = Bool->FALSE;
      unless ($object is_type Bool) {
        return 0;
      }
    }
    
    # Exception variable
    {
      eval {
        die Error::System "[System Error]";
      }
      
      unless ($@ is_type Error::System) {
        return 0;
      }
      
      if ($@ is_type Error) {
        return 0;
      }
      
      unless ($@ is_type string) {
        return 0;
      }
      
      $@ = undef;
      
      if ($@ is_type Error::System) {
        return 0;
      }
      
      if ($@ is_type Error) {
        return 0;
      }
      
      if ($@ is_type string) {
        return 0;
      }
      
    }
    
    return 1;
  }
  
  static method is_error : int () {
    
    {
      my $error_basic_type_id = basic_type_id Error;
      
      unless ($error_basic_type_id is_error Error) {
        return 0;
      }
    }

    {
      my $error_system_basic_type_id = basic_type_id Error::System;
      
      if ($error_system_basic_type_id is_error Error) {
        return 0;
      }
      
      unless ($error_system_basic_type_id is_error Error::System) {
        return 0;
      }
    }
    
    {
      my $error_not_supported_basic_type_id = basic_type_id Error::NotSupported;
      
      if ($error_not_supported_basic_type_id is_error Error) {
        return 0;
      }
      
      unless ($error_not_supported_basic_type_id is_error Error::NotSupported) {
        return 0;
      }
    }
    
    # Extra
    {
      eval { die; }
      
      unless (eval_error_id is_error Error) {
        return 0;
      }
    }
    
    $@ = undef;
    
    return 1;
  }
}
